Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
4test cases
4files differ
0modified
4new
0deleted
12,059changed lines
+12,059 −0insertions / deletions
Base 10cdaef273530caef2fdf9afdc07cdd0d1f9cae7 · PR merge c7b01b61c598d96c25b446bd5bf93d98b752c36d · Head a11e97bcf9c6e6e9f2311b175ccb66ebad353637 · raw patch
Test case

test/inputs/json/priority/combinations1.json

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

test/inputs/json/priority/combinations2.json

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

test/inputs/json/priority/combinations3.json

1 generated file · +3,095 −0
Aswiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+3,095 −0
@@ -0,0 +1,3095 @@
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+struct TopLevel: Codable {
10+ let juror: [TopLevel.JurorElement]
11+ let kongoni: [TopLevel.Kongoni]
12+ let ladronism: [TopLevel.LadronismElement]
13+ let landlubberly: [TopLevel.LandlubberlyElement]
14+ let listener: [TopLevel.Listener]
15+ let lupus: [TopLevel.LupusElement]
16+ let maslin: [TopLevel.Maslin]
17+ let monazite: [TopLevel.MonaziteElement]
18+ let monoliteral: [TopLevel.Monoliteral]
19+ let monotheistically: [TopLevel.MonotheisticallyElement]
20+ let montage: [TopLevel.Montage]
21+ let moralness: [TopLevel.Moralness]
22+ let mowra: [TopLevel.MonaziteClass?]
23+ let mulishly: [TopLevel.Mulishly]
24+ let myoscope: [TopLevel.Myoscope]
25+ let nach: [[Int?]?]
26+ let neuromastic: [TopLevel.Neuromastic]
27+ let noncontributing: [TopLevel.Noncontributing]
28+ let nonnervous: [TopLevel.Nonnervous]
29+ let nonvaluation: [TopLevel.Nonvaluation]
30+ let occupationalist: [TopLevel.OccupationalistElement]
31+ let outrival: [TopLevel.OutrivalElement]
32+ let paleographically: [TopLevel.Paleographically]
33+ let pamphletwise: [TopLevel.Pamphletwise]
34+ let pediatrics: [TopLevel.Pediatric]
35+ let perceptive: [Bool]
36+ let piaculum: [TopLevel.PiaculumElement]
37+ let piccadilly: [TopLevel.Piccadilly]
38+ let piffler: [TopLevel.Piffler]
39+ let pithful: [TopLevel.Pithful]
40+ let placuntitis: [TopLevel.Placuntiti]
41+ let plectopterous: [TopLevel.Plectopterous]
42+ let pneumocele: [TopLevel.Pneumocele?]
43+ let poliorcetic: [TopLevel.Poliorcetic]
44+ let poormaster: [TopLevel.Poormaster]
45+ let potwhisky: [TopLevel.PotwhiskyElement]
46+ let practicalizer: [TopLevel.Practicalizer]
47+ let prefreshman: [TopLevel.PrefreshmanElement]
48+ let prehensility: [TopLevel.Prehensility]
49+ let prevoidance: [TopLevel.Prevoidance]
50+ let probant: [[String: Int?]]
51+ let protext: [TopLevel.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+ enum JurorElement: Codable {
99+ case bool(Bool)
100+ case jurorClass(TopLevel.JurorClass)
101+
102+ init(from decoder: Decoder) throws {
103+ let container = try decoder.singleValueContainer()
104+ if let x = try? container.decode(Bool.self) {
105+ self = .bool(x)
106+ return
107+ }
108+ if let x = try? container.decode(TopLevel.JurorClass.self) {
109+ self = .jurorClass(x)
110+ return
111+ }
112+ throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement"))
113+ }
114+
115+ func encode(to encoder: Encoder) throws {
116+ var container = encoder.singleValueContainer()
117+ switch self {
118+ case .bool(let x):
119+ try container.encode(x)
120+ case .jurorClass(let x):
121+ try container.encode(x)
122+ }
123+ }
124+ }
125+
126+ struct JurorClass: Codable {
127+ let adipsy: JSONNull?
128+ let auxiliator: JSONNull?
129+ let benda: JSONNull?
130+ let benjamin: JSONNull?
131+ let brandling: JSONNull?
132+ let epicurishly: JSONNull?
133+ let eremochaetous: JSONNull?
134+ let marten: JSONNull?
135+ let monocline: JSONNull?
136+ let olea: JSONNull?
137+ let palgat: JSONNull?
138+ let pennyworth: JSONNull?
139+ let pioury: JSONNull?
140+ let pragmatistic: JSONNull?
141+ let stylelessness: JSONNull?
142+ let systematical: JSONNull?
143+ let thready: JSONNull?
144+ let uncontemporary: JSONNull?
145+ let uncouched: JSONNull?
146+ let uninhabitedness: JSONNull?
147+
148+ enum CodingKeys: String, CodingKey {
149+ case adipsy = "adipsy"
150+ case auxiliator = "auxiliator"
151+ case benda = "benda"
152+ case benjamin = "benjamin"
153+ case brandling = "brandling"
154+ case epicurishly = "epicurishly"
155+ case eremochaetous = "eremochaetous"
156+ case marten = "marten"
157+ case monocline = "monocline"
158+ case olea = "Olea"
159+ case palgat = "palgat"
160+ case pennyworth = "pennyworth"
161+ case pioury = "pioury"
162+ case pragmatistic = "pragmatistic"
163+ case stylelessness = "stylelessness"
164+ case systematical = "systematical"
165+ case thready = "thready"
166+ case uncontemporary = "uncontemporary"
167+ case uncouched = "uncouched"
168+ case uninhabitedness = "uninhabitedness"
169+ }
170+ }
171+
172+ enum Kongoni: Codable {
173+ case integerArray([Int])
174+ case integerMap([String: Int])
175+
176+ init(from decoder: Decoder) throws {
177+ let container = try decoder.singleValueContainer()
178+ if let x = try? container.decode([Int].self) {
179+ self = .integerArray(x)
180+ return
181+ }
182+ if let x = try? container.decode([String: Int].self) {
183+ self = .integerMap(x)
184+ return
185+ }
186+ throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni"))
187+ }
188+
189+ func encode(to encoder: Encoder) throws {
190+ var container = encoder.singleValueContainer()
191+ switch self {
192+ case .integerArray(let x):
193+ try container.encode(x)
194+ case .integerMap(let x):
195+ try container.encode(x)
196+ }
197+ }
198+ }
199+
200+ enum LadronismElement: Codable {
201+ case double(Double)
202+ case ladronismClass(TopLevel.LadronismClass)
203+ case string(String)
204+
205+ init(from decoder: Decoder) throws {
206+ let container = try decoder.singleValueContainer()
207+ if let x = try? container.decode(Double.self) {
208+ self = .double(x)
209+ return
210+ }
211+ if let x = try? container.decode(String.self) {
212+ self = .string(x)
213+ return
214+ }
215+ if let x = try? container.decode(TopLevel.LadronismClass.self) {
216+ self = .ladronismClass(x)
217+ return
218+ }
219+ throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement"))
220+ }
221+
222+ func encode(to encoder: Encoder) throws {
223+ var container = encoder.singleValueContainer()
224+ switch self {
225+ case .double(let x):
226+ try container.encode(x)
227+ case .ladronismClass(let x):
228+ try container.encode(x)
229+ case .string(let x):
230+ try container.encode(x)
231+ }
232+ }
233+ }
234+
235+ struct LadronismClass: Codable {
236+ let acclaimer: JSONNull?
237+ let achree: JSONNull?
238+ let base: JSONNull?
239+ let conundrumize: JSONNull?
240+ let degerminator: JSONNull?
241+ let describable: JSONNull?
242+ let exasperatedly: JSONNull?
243+ let heroine: JSONNull?
244+ let indazin: JSONNull?
245+ let luteous: JSONNull?
246+ let papular: JSONNull?
247+ let pritch: JSONNull?
248+ let prodenia: JSONNull?
249+ let seege: JSONNull?
250+ let shopgirl: JSONNull?
251+ let tragedietta: JSONNull?
252+ let unsparse: JSONNull?
253+ let uplook: JSONNull?
254+ let vermiformis: JSONNull?
255+ let whafabout: JSONNull?
256+
257+ enum CodingKeys: String, CodingKey {
258+ case acclaimer = "acclaimer"
259+ case achree = "achree"
260+ case base = "base"
261+ case conundrumize = "conundrumize"
262+ case degerminator = "degerminator"
263+ case describable = "describable"
264+ case exasperatedly = "exasperatedly"
265+ case heroine = "heroine"
266+ case indazin = "indazin"
267+ case luteous = "luteous"
268+ case papular = "papular"
269+ case pritch = "pritch"
270+ case prodenia = "Prodenia"
271+ case seege = "seege"
272+ case shopgirl = "shopgirl"
273+ case tragedietta = "tragedietta"
274+ case unsparse = "unsparse"
275+ case uplook = "uplook"
276+ case vermiformis = "vermiformis"
277+ case whafabout = "whafabout"
278+ }
279+ }
280+
281+ enum LandlubberlyElement: Codable {
282+ case bool(Bool)
283+ case integer(Int)
284+ case landlubberlyClass(TopLevel.LandlubberlyClass)
285+
286+ init(from decoder: Decoder) throws {
287+ let container = try decoder.singleValueContainer()
288+ if let x = try? container.decode(Bool.self) {
289+ self = .bool(x)
290+ return
291+ }
292+ if let x = try? container.decode(Int.self) {
293+ self = .integer(x)
294+ return
295+ }
296+ if let x = try? container.decode(TopLevel.LandlubberlyClass.self) {
297+ self = .landlubberlyClass(x)
298+ return
299+ }
300+ throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement"))
301+ }
302+
303+ func encode(to encoder: Encoder) throws {
304+ var container = encoder.singleValueContainer()
305+ switch self {
306+ case .bool(let x):
307+ try container.encode(x)
308+ case .integer(let x):
309+ try container.encode(x)
310+ case .landlubberlyClass(let x):
311+ try container.encode(x)
312+ }
313+ }
314+ }
315+
316+ struct LandlubberlyClass: Codable {
317+ let acropoleis: JSONNull?
318+ let aminate: JSONNull?
319+ let amyraldism: JSONNull?
320+ let bipenniform: JSONNull?
321+ let bugre: JSONNull?
322+ let calycule: JSONNull?
323+ let caoutchouc: JSONNull?
324+ let disprover: JSONNull?
325+ let fitroot: JSONNull?
326+ let fulgently: JSONNull?
327+ let kickup: JSONNull?
328+ let laevoversion: JSONNull?
329+ let moter: JSONNull?
330+ let objectivity: JSONNull?
331+ let posterity: JSONNull?
332+ let postnuptial: JSONNull?
333+ let precedentary: JSONNull?
334+ let saddling: JSONNull?
335+ let subcurrent: JSONNull?
336+ let unrecriminative: JSONNull?
337+
338+ enum CodingKeys: String, CodingKey {
339+ case acropoleis = "acropoleis"
340+ case aminate = "aminate"
341+ case amyraldism = "Amyraldism"
342+ case bipenniform = "bipenniform"
343+ case bugre = "bugre"
344+ case calycule = "calycule"
345+ case caoutchouc = "caoutchouc"
346+ case disprover = "disprover"
347+ case fitroot = "fitroot"
348+ case fulgently = "fulgently"
349+ case kickup = "kickup"
350+ case laevoversion = "laevoversion"
351+ case moter = "moter"
352+ case objectivity = "objectivity"
353+ case posterity = "posterity"
354+ case postnuptial = "postnuptial"
355+ case precedentary = "precedentary"
356+ case saddling = "saddling"
357+ case subcurrent = "subcurrent"
358+ case unrecriminative = "unrecriminative"
359+ }
360+ }
361+
362+ enum Listener: Codable {
363+ case integer(Int)
364+ case nullArray([JSONNull?])
365+
366+ init(from decoder: Decoder) throws {
367+ let container = try decoder.singleValueContainer()
368+ if let x = try? container.decode(Int.self) {
369+ self = .integer(x)
370+ return
371+ }
372+ if let x = try? container.decode([JSONNull?].self) {
373+ self = .nullArray(x)
374+ return
375+ }
376+ throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener"))
377+ }
378+
379+ func encode(to encoder: Encoder) throws {
380+ var container = encoder.singleValueContainer()
381+ switch self {
382+ case .integer(let x):
383+ try container.encode(x)
384+ case .nullArray(let x):
385+ try container.encode(x)
386+ }
387+ }
388+ }
389+
390+ enum LupusElement: Codable {
391+ case integer(Int)
392+ case lupusClass(TopLevel.LupusClass)
393+
394+ init(from decoder: Decoder) throws {
395+ let container = try decoder.singleValueContainer()
396+ if let x = try? container.decode(Int.self) {
397+ self = .integer(x)
398+ return
399+ }
400+ if let x = try? container.decode(TopLevel.LupusClass.self) {
401+ self = .lupusClass(x)
402+ return
403+ }
404+ throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement"))
405+ }
406+
407+ func encode(to encoder: Encoder) throws {
408+ var container = encoder.singleValueContainer()
409+ switch self {
410+ case .integer(let x):
411+ try container.encode(x)
412+ case .lupusClass(let x):
413+ try container.encode(x)
414+ }
415+ }
416+ }
417+
418+ struct LupusClass: Codable {
419+ let catharticalness: Double?
420+ let chirotherium: Int?
421+ let chlorioninae: Int?
422+ let corvinae: Int?
423+ let crassina: Int?
424+ let disdiapason: String?
425+ let exiguity: Int?
426+ let farcist: Int?
427+ let holographical: Int?
428+ let homocerc: Bool?
429+ let ichthyophagan: Int?
430+ let implacable: Int?
431+ let nonbookish: JSONNull?
432+ let outshiner: Int?
433+ let overweather: Int?
434+ let protonegroid: Int?
435+ let shallowish: Int?
436+ let snoke: Int?
437+ let snout: Int?
438+ let surveillance: Int?
439+ let threshingtime: Int?
440+ let thysanocarpus: Int?
441+ let unsignificantly: Int?
442+ let unsnap: Int?
443+ let vendible: Int?
444+
445+ enum CodingKeys: String, CodingKey {
446+ case catharticalness = "catharticalness"
447+ case chirotherium = "Chirotherium"
448+ case chlorioninae = "Chlorioninae"
449+ case corvinae = "Corvinae"
450+ case crassina = "Crassina"
451+ case disdiapason = "disdiapason"
452+ case exiguity = "exiguity"
453+ case farcist = "farcist"
454+ case holographical = "holographical"
455+ case homocerc = "homocerc"
456+ case ichthyophagan = "ichthyophagan"
457+ case implacable = "implacable"
458+ case nonbookish = "nonbookish"
459+ case outshiner = "outshiner"
460+ case overweather = "overweather"
461+ case protonegroid = "protonegroid"
462+ case shallowish = "shallowish"
463+ case snoke = "snoke"
464+ case snout = "snout"
465+ case surveillance = "surveillance"
466+ case threshingtime = "threshingtime"
467+ case thysanocarpus = "Thysanocarpus"
468+ case unsignificantly = "unsignificantly"
469+ case unsnap = "unsnap"
470+ case vendible = "vendible"
471+ }
472+ }
473+
474+ struct Maslin: Codable {
475+ let alicant: Int?
476+ let antiatonement: JSONNull?
477+ let anticorrosive: Int?
478+ let aphidozer: JSONNull?
479+ let bakuninist: JSONNull?
480+ let be: Int?
481+ let catharticalness: Double?
482+ let chirotherium: Int?
483+ let chub: Int?
484+ let cuprosilicon: Int?
485+ let curtailedly: Int?
486+ let dellenite: Int?
487+ let dimitry: Int?
488+ let disdiapason: String?
489+ let edifying: JSONNull?
490+ let ethmoiditis: Int?
491+ let gastralgy: JSONNull?
492+ let goatherd: Int?
493+ let hammerdress: Int?
494+ let hangfire: JSONNull?
495+ let homocerc: Bool?
496+ let lacunosity: Int?
497+ let longiloquence: JSONNull?
498+ let mameliere: Int?
499+ let motherless: JSONNull?
500+ let nonbookish: JSONNull?
501+ let noncorrodible: JSONNull?
502+ let nonsensicality: JSONNull?
503+ let oafishly: Int?
504+ let pfund: JSONNull?
505+ let preadvisory: JSONNull?
506+ let retroflexed: JSONNull?
507+ let saccharulmic: Int?
508+ let scowlful: Int?
509+ let secluded: JSONNull?
510+ let slackage: JSONNull?
511+ let sphaeridial: Int?
512+ let spondulics: JSONNull?
513+ let subsecive: Int?
514+ let swellmobsman: JSONNull?
515+ let trachyglossate: Int?
516+ let trialogue: JSONNull?
517+ let unassuaged: Int?
518+ let ungross: JSONNull?
519+ let unjudiciously: JSONNull?
520+
521+ enum CodingKeys: String, CodingKey {
522+ case alicant = "Alicant"
523+ case antiatonement = "antiatonement"
524+ case anticorrosive = "anticorrosive"
525+ case aphidozer = "aphidozer"
526+ case bakuninist = "Bakuninist"
527+ case be = "be"
528+ case catharticalness = "catharticalness"
529+ case chirotherium = "Chirotherium"
530+ case chub = "chub"
531+ case cuprosilicon = "cuprosilicon"
532+ case curtailedly = "curtailedly"
533+ case dellenite = "dellenite"
534+ case dimitry = "Dimitry"
535+ case disdiapason = "disdiapason"
536+ case edifying = "edifying"
537+ case ethmoiditis = "ethmoiditis"
538+ case gastralgy = "gastralgy"
539+ case goatherd = "goatherd"
540+ case hammerdress = "hammerdress"
541+ case hangfire = "hangfire"
542+ case homocerc = "homocerc"
543+ case lacunosity = "lacunosity"
544+ case longiloquence = "longiloquence"
545+ case mameliere = "mameliere"
546+ case motherless = "motherless"
547+ case nonbookish = "nonbookish"
548+ case noncorrodible = "noncorrodible"
549+ case nonsensicality = "nonsensicality"
550+ case oafishly = "oafishly"
551+ case pfund = "pfund"
552+ case preadvisory = "preadvisory"
553+ case retroflexed = "retroflexed"
554+ case saccharulmic = "saccharulmic"
555+ case scowlful = "scowlful"
556+ case secluded = "secluded"
557+ case slackage = "slackage"
558+ case sphaeridial = "sphaeridial"
559+ case spondulics = "spondulics"
560+ case subsecive = "subsecive"
561+ case swellmobsman = "swellmobsman"
562+ case trachyglossate = "trachyglossate"
563+ case trialogue = "trialogue"
564+ case unassuaged = "unassuaged"
565+ case ungross = "ungross"
566+ case unjudiciously = "unjudiciously"
567+ }
568+ }
569+
570+ enum MonaziteElement: Codable {
571+ case double(Double)
572+ case monaziteClass(TopLevel.MonaziteClass)
573+
574+ init(from decoder: Decoder) throws {
575+ let container = try decoder.singleValueContainer()
576+ if let x = try? container.decode(Double.self) {
577+ self = .double(x)
578+ return
579+ }
580+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
581+ self = .monaziteClass(x)
582+ return
583+ }
584+ throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement"))
585+ }
586+
587+ func encode(to encoder: Encoder) throws {
588+ var container = encoder.singleValueContainer()
589+ switch self {
590+ case .double(let x):
591+ try container.encode(x)
592+ case .monaziteClass(let x):
593+ try container.encode(x)
594+ }
595+ }
596+ }
597+
598+ struct MonaziteClass: Codable {
599+ let catharticalness: Double
600+ let chirotherium: Int
601+ let disdiapason: String
602+ let homocerc: Bool
603+ let nonbookish: JSONNull?
604+
605+ enum CodingKeys: String, CodingKey {
606+ case catharticalness = "catharticalness"
607+ case chirotherium = "Chirotherium"
608+ case disdiapason = "disdiapason"
609+ case homocerc = "homocerc"
610+ case nonbookish = "nonbookish"
611+ }
612+ }
613+
614+ enum Monoliteral: Codable {
615+ case bool(Bool)
616+ case nullArray([JSONNull?])
617+
618+ init(from decoder: Decoder) throws {
619+ let container = try decoder.singleValueContainer()
620+ if let x = try? container.decode(Bool.self) {
621+ self = .bool(x)
622+ return
623+ }
624+ if let x = try? container.decode([JSONNull?].self) {
625+ self = .nullArray(x)
626+ return
627+ }
628+ throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral"))
629+ }
630+
631+ func encode(to encoder: Encoder) throws {
632+ var container = encoder.singleValueContainer()
633+ switch self {
634+ case .bool(let x):
635+ try container.encode(x)
636+ case .nullArray(let x):
637+ try container.encode(x)
638+ }
639+ }
640+ }
641+
642+ enum MonotheisticallyElement: Codable {
643+ case monotheisticallyClass(TopLevel.MonotheisticallyClass)
644+ case nullArray([JSONNull?])
645+
646+ init(from decoder: Decoder) throws {
647+ let container = try decoder.singleValueContainer()
648+ if let x = try? container.decode([JSONNull?].self) {
649+ self = .nullArray(x)
650+ return
651+ }
652+ if let x = try? container.decode(TopLevel.MonotheisticallyClass.self) {
653+ self = .monotheisticallyClass(x)
654+ return
655+ }
656+ throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement"))
657+ }
658+
659+ func encode(to encoder: Encoder) throws {
660+ var container = encoder.singleValueContainer()
661+ switch self {
662+ case .monotheisticallyClass(let x):
663+ try container.encode(x)
664+ case .nullArray(let x):
665+ try container.encode(x)
666+ }
667+ }
668+ }
669+
670+ struct MonotheisticallyClass: Codable {
671+ let blaspheme: JSONNull?
672+ let catharticalness: Double?
673+ let celiosalpingectomy: JSONNull?
674+ let chirotherium: Int?
675+ let consummativeness: JSONNull?
676+ let disdiapason: String?
677+ let egestive: JSONNull?
678+ let enchylema: JSONNull?
679+ let gasconade: JSONNull?
680+ let holidayer: JSONNull?
681+ let homocerc: Bool?
682+ let intuitionalism: JSONNull?
683+ let lophiostomate: JSONNull?
684+ let nonbookish: JSONNull?
685+ let nonvolition: JSONNull?
686+ let palatableness: JSONNull?
687+ let pimpery: JSONNull?
688+ let previolation: JSONNull?
689+ let reconveyance: JSONNull?
690+ let registership: JSONNull?
691+ let rhyacolite: JSONNull?
692+ let smithereens: JSONNull?
693+ let superedification: JSONNull?
694+ let trust: JSONNull?
695+ let whitestone: JSONNull?
696+
697+ enum CodingKeys: String, CodingKey {
698+ case blaspheme = "blaspheme"
699+ case catharticalness = "catharticalness"
700+ case celiosalpingectomy = "celiosalpingectomy"
701+ case chirotherium = "Chirotherium"
702+ case consummativeness = "consummativeness"
703+ case disdiapason = "disdiapason"
704+ case egestive = "egestive"
705+ case enchylema = "enchylema"
706+ case gasconade = "gasconade"
707+ case holidayer = "holidayer"
708+ case homocerc = "homocerc"
709+ case intuitionalism = "intuitionalism"
710+ case lophiostomate = "lophiostomate"
711+ case nonbookish = "nonbookish"
712+ case nonvolition = "nonvolition"
713+ case palatableness = "palatableness"
714+ case pimpery = "pimpery"
715+ case previolation = "previolation"
716+ case reconveyance = "reconveyance"
717+ case registership = "registership"
718+ case rhyacolite = "rhyacolite"
719+ case smithereens = "smithereens"
720+ case superedification = "superedification"
721+ case trust = "trust"
722+ case whitestone = "whitestone"
723+ }
724+ }
725+
726+ enum Montage: Codable {
727+ case double(Double)
728+ case nullArray([JSONNull?])
729+ case string(String)
730+
731+ init(from decoder: Decoder) throws {
732+ let container = try decoder.singleValueContainer()
733+ if let x = try? container.decode([JSONNull?].self) {
734+ self = .nullArray(x)
735+ return
736+ }
737+ if let x = try? container.decode(Double.self) {
738+ self = .double(x)
739+ return
740+ }
741+ if let x = try? container.decode(String.self) {
742+ self = .string(x)
743+ return
744+ }
745+ throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage"))
746+ }
747+
748+ func encode(to encoder: Encoder) throws {
749+ var container = encoder.singleValueContainer()
750+ switch self {
751+ case .double(let x):
752+ try container.encode(x)
753+ case .nullArray(let x):
754+ try container.encode(x)
755+ case .string(let x):
756+ try container.encode(x)
757+ }
758+ }
759+ }
760+
761+ enum Moralness: Codable {
762+ case double(Double)
763+ case nullArray([JSONNull?])
764+ case null
765+
766+ init(from decoder: Decoder) throws {
767+ let container = try decoder.singleValueContainer()
768+ if let x = try? container.decode([JSONNull?].self) {
769+ self = .nullArray(x)
770+ return
771+ }
772+ if let x = try? container.decode(Double.self) {
773+ self = .double(x)
774+ return
775+ }
776+ if container.decodeNil() {
777+ self = .null
778+ return
779+ }
780+ throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness"))
781+ }
782+
783+ func encode(to encoder: Encoder) throws {
784+ var container = encoder.singleValueContainer()
785+ switch self {
786+ case .double(let x):
787+ try container.encode(x)
788+ case .nullArray(let x):
789+ try container.encode(x)
790+ case .null:
791+ try container.encodeNil()
792+ }
793+ }
794+ }
795+
796+ enum Mulishly: Codable {
797+ case double(Double)
798+ case integerArray([Int])
799+ case null
800+
801+ init(from decoder: Decoder) throws {
802+ let container = try decoder.singleValueContainer()
803+ if let x = try? container.decode([Int].self) {
804+ self = .integerArray(x)
805+ return
806+ }
807+ if let x = try? container.decode(Double.self) {
808+ self = .double(x)
809+ return
810+ }
811+ if container.decodeNil() {
812+ self = .null
813+ return
814+ }
815+ throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly"))
816+ }
817+
818+ func encode(to encoder: Encoder) throws {
819+ var container = encoder.singleValueContainer()
820+ switch self {
821+ case .double(let x):
822+ try container.encode(x)
823+ case .integerArray(let x):
824+ try container.encode(x)
825+ case .null:
826+ try container.encodeNil()
827+ }
828+ }
829+ }
830+
831+ enum Myoscope: Codable {
832+ case bool(Bool)
833+ case integer(Int)
834+ case nullArray([JSONNull?])
835+
836+ init(from decoder: Decoder) throws {
837+ let container = try decoder.singleValueContainer()
838+ if let x = try? container.decode(Bool.self) {
839+ self = .bool(x)
840+ return
841+ }
842+ if let x = try? container.decode(Int.self) {
843+ self = .integer(x)
844+ return
845+ }
846+ if let x = try? container.decode([JSONNull?].self) {
847+ self = .nullArray(x)
848+ return
849+ }
850+ throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope"))
851+ }
852+
853+ func encode(to encoder: Encoder) throws {
854+ var container = encoder.singleValueContainer()
855+ switch self {
856+ case .bool(let x):
857+ try container.encode(x)
858+ case .integer(let x):
859+ try container.encode(x)
860+ case .nullArray(let x):
861+ try container.encode(x)
862+ }
863+ }
864+ }
865+
866+ enum Neuromastic: Codable {
867+ case double(Double)
868+ case nullArray([JSONNull?])
869+
870+ init(from decoder: Decoder) throws {
871+ let container = try decoder.singleValueContainer()
872+ if let x = try? container.decode([JSONNull?].self) {
873+ self = .nullArray(x)
874+ return
875+ }
876+ if let x = try? container.decode(Double.self) {
877+ self = .double(x)
878+ return
879+ }
880+ throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic"))
881+ }
882+
883+ func encode(to encoder: Encoder) throws {
884+ var container = encoder.singleValueContainer()
885+ switch self {
886+ case .double(let x):
887+ try container.encode(x)
888+ case .nullArray(let x):
889+ try container.encode(x)
890+ }
891+ }
892+ }
893+
894+ struct Noncontributing: Codable {
895+ let estevin: String
896+ let jolterhead: Double
897+ let sauternes: Int
898+ let sparsely: Bool
899+ let unrequested: JSONNull?
900+
901+ enum CodingKeys: String, CodingKey {
902+ case estevin = "estevin"
903+ case jolterhead = "jolterhead"
904+ case sauternes = "sauternes"
905+ case sparsely = "sparsely"
906+ case unrequested = "unrequested"
907+ }
908+ }
909+
910+ enum Nonnervous: Codable {
911+ case bool(Bool)
912+ case integer(Int)
913+
914+ init(from decoder: Decoder) throws {
915+ let container = try decoder.singleValueContainer()
916+ if let x = try? container.decode(Bool.self) {
917+ self = .bool(x)
918+ return
919+ }
920+ if let x = try? container.decode(Int.self) {
921+ self = .integer(x)
922+ return
923+ }
924+ throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous"))
925+ }
926+
927+ func encode(to encoder: Encoder) throws {
928+ var container = encoder.singleValueContainer()
929+ switch self {
930+ case .bool(let x):
931+ try container.encode(x)
932+ case .integer(let x):
933+ try container.encode(x)
934+ }
935+ }
936+ }
937+
938+ enum Nonvaluation: Codable {
939+ case bool(Bool)
940+ case double(Double)
941+ case nullArray([JSONNull?])
942+
943+ init(from decoder: Decoder) throws {
944+ let container = try decoder.singleValueContainer()
945+ if let x = try? container.decode(Bool.self) {
946+ self = .bool(x)
947+ return
948+ }
949+ if let x = try? container.decode([JSONNull?].self) {
950+ self = .nullArray(x)
951+ return
952+ }
953+ if let x = try? container.decode(Double.self) {
954+ self = .double(x)
955+ return
956+ }
957+ throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation"))
958+ }
959+
960+ func encode(to encoder: Encoder) throws {
961+ var container = encoder.singleValueContainer()
962+ switch self {
963+ case .bool(let x):
964+ try container.encode(x)
965+ case .double(let x):
966+ try container.encode(x)
967+ case .nullArray(let x):
968+ try container.encode(x)
969+ }
970+ }
971+ }
972+
973+ enum OccupationalistElement: Codable {
974+ case nullArray([JSONNull?])
975+ case occupationalistClass(TopLevel.OccupationalistClass)
976+ case null
977+
978+ init(from decoder: Decoder) throws {
979+ let container = try decoder.singleValueContainer()
980+ if let x = try? container.decode([JSONNull?].self) {
981+ self = .nullArray(x)
982+ return
983+ }
984+ if let x = try? container.decode(TopLevel.OccupationalistClass.self) {
985+ self = .occupationalistClass(x)
986+ return
987+ }
988+ if container.decodeNil() {
989+ self = .null
990+ return
991+ }
992+ throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement"))
993+ }
994+
995+ func encode(to encoder: Encoder) throws {
996+ var container = encoder.singleValueContainer()
997+ switch self {
998+ case .nullArray(let x):
999+ try container.encode(x)
1000+ case .occupationalistClass(let x):
1001+ try container.encode(x)
1002+ case .null:
1003+ try container.encodeNil()
1004+ }
1005+ }
1006+ }
1007+
1008+ struct OccupationalistClass: Codable {
1009+ let beholdable: JSONNull?
1010+ let brotuliform: JSONNull?
1011+ let chimakum: JSONNull?
1012+ let doodler: JSONNull?
1013+ let emulsin: JSONNull?
1014+ let fin: JSONNull?
1015+ let flourishing: JSONNull?
1016+ let flueless: JSONNull?
1017+ let furtively: JSONNull?
1018+ let gritter: JSONNull?
1019+ let interwish: JSONNull?
1020+ let monoxylic: JSONNull?
1021+ let myristic: JSONNull?
1022+ let nightwear: JSONNull?
1023+ let peruser: JSONNull?
1024+ let theoastrological: JSONNull?
1025+ let thumby: JSONNull?
1026+ let tingitid: JSONNull?
1027+ let trailless: JSONNull?
1028+ let unpocketed: JSONNull?
1029+
1030+ enum CodingKeys: String, CodingKey {
1031+ case beholdable = "beholdable"
1032+ case brotuliform = "brotuliform"
1033+ case chimakum = "Chimakum"
1034+ case doodler = "doodler"
1035+ case emulsin = "emulsin"
1036+ case fin = "Fin"
1037+ case flourishing = "flourishing"
1038+ case flueless = "flueless"
1039+ case furtively = "furtively"
1040+ case gritter = "gritter"
1041+ case interwish = "interwish"
1042+ case monoxylic = "monoxylic"
1043+ case myristic = "myristic"
1044+ case nightwear = "nightwear"
1045+ case peruser = "peruser"
1046+ case theoastrological = "theoastrological"
1047+ case thumby = "thumby"
1048+ case tingitid = "tingitid"
1049+ case trailless = "trailless"
1050+ case unpocketed = "unpocketed"
1051+ }
1052+ }
1053+
1054+ enum OutrivalElement: Codable {
1055+ case double(Double)
1056+ case outrivalClass(TopLevel.OutrivalClass)
1057+ case null
1058+
1059+ init(from decoder: Decoder) throws {
1060+ let container = try decoder.singleValueContainer()
1061+ if let x = try? container.decode(Double.self) {
1062+ self = .double(x)
1063+ return
1064+ }
1065+ if let x = try? container.decode(TopLevel.OutrivalClass.self) {
1066+ self = .outrivalClass(x)
1067+ return
1068+ }
1069+ if container.decodeNil() {
1070+ self = .null
1071+ return
1072+ }
1073+ throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement"))
1074+ }
1075+
1076+ func encode(to encoder: Encoder) throws {
1077+ var container = encoder.singleValueContainer()
1078+ switch self {
1079+ case .double(let x):
1080+ try container.encode(x)
1081+ case .outrivalClass(let x):
1082+ try container.encode(x)
1083+ case .null:
1084+ try container.encodeNil()
1085+ }
1086+ }
1087+ }
1088+
1089+ struct OutrivalClass: Codable {
1090+ let adroitly: JSONNull?
1091+ let bridehood: JSONNull?
1092+ let castoroides: JSONNull?
1093+ let czechoslovak: JSONNull?
1094+ let diagenesis: JSONNull?
1095+ let dihexahedron: JSONNull?
1096+ let dopester: JSONNull?
1097+ let eumerism: JSONNull?
1098+ let flyness: JSONNull?
1099+ let fouler: JSONNull?
1100+ let laudanosine: JSONNull?
1101+ let lingulidae: JSONNull?
1102+ let minutary: JSONNull?
1103+ let mitra: JSONNull?
1104+ let opisthorchiasis: JSONNull?
1105+ let pensively: JSONNull?
1106+ let pubigerous: JSONNull?
1107+ let rebellious: JSONNull?
1108+ let recodify: JSONNull?
1109+ let unpaced: JSONNull?
1110+
1111+ enum CodingKeys: String, CodingKey {
1112+ case adroitly = "adroitly"
1113+ case bridehood = "bridehood"
1114+ case castoroides = "Castoroides"
1115+ case czechoslovak = "Czechoslovak"
1116+ case diagenesis = "diagenesis"
1117+ case dihexahedron = "dihexahedron"
1118+ case dopester = "dopester"
1119+ case eumerism = "eumerism"
1120+ case flyness = "flyness"
1121+ case fouler = "fouler"
1122+ case laudanosine = "laudanosine"
1123+ case lingulidae = "Lingulidae"
1124+ case minutary = "minutary"
1125+ case mitra = "mitra"
1126+ case opisthorchiasis = "opisthorchiasis"
1127+ case pensively = "pensively"
1128+ case pubigerous = "pubigerous"
1129+ case rebellious = "rebellious"
1130+ case recodify = "recodify"
1131+ case unpaced = "unpaced"
1132+ }
1133+ }
1134+
1135+ enum Paleographically: Codable {
1136+ case double(Double)
1137+ case unionMap([String: Int?])
1138+
1139+ init(from decoder: Decoder) throws {
1140+ let container = try decoder.singleValueContainer()
1141+ if let x = try? container.decode(Double.self) {
1142+ self = .double(x)
1143+ return
1144+ }
1145+ if let x = try? container.decode([String: Int?].self) {
1146+ self = .unionMap(x)
1147+ return
1148+ }
1149+ throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically"))
1150+ }
1151+
1152+ func encode(to encoder: Encoder) throws {
1153+ var container = encoder.singleValueContainer()
1154+ switch self {
1155+ case .double(let x):
1156+ try container.encode(x)
1157+ case .unionMap(let x):
1158+ try container.encode(x)
1159+ }
1160+ }
1161+ }
1162+
1163+ enum Pamphletwise: Codable {
1164+ case integer(Int)
1165+ case integerMap([String: Int])
1166+ case string(String)
1167+
1168+ init(from decoder: Decoder) throws {
1169+ let container = try decoder.singleValueContainer()
1170+ if let x = try? container.decode(Int.self) {
1171+ self = .integer(x)
1172+ return
1173+ }
1174+ if let x = try? container.decode([String: Int].self) {
1175+ self = .integerMap(x)
1176+ return
1177+ }
1178+ if let x = try? container.decode(String.self) {
1179+ self = .string(x)
1180+ return
1181+ }
1182+ throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise"))
1183+ }
1184+
1185+ func encode(to encoder: Encoder) throws {
1186+ var container = encoder.singleValueContainer()
1187+ switch self {
1188+ case .integer(let x):
1189+ try container.encode(x)
1190+ case .integerMap(let x):
1191+ try container.encode(x)
1192+ case .string(let x):
1193+ try container.encode(x)
1194+ }
1195+ }
1196+ }
1197+
1198+ enum Pediatric: Codable {
1199+ case bool(Bool)
1200+ case double(Double)
1201+ case null
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(Double.self) {
1210+ self = .double(x)
1211+ return
1212+ }
1213+ if container.decodeNil() {
1214+ self = .null
1215+ return
1216+ }
1217+ throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric"))
1218+ }
1219+
1220+ func encode(to encoder: Encoder) throws {
1221+ var container = encoder.singleValueContainer()
1222+ switch self {
1223+ case .bool(let x):
1224+ try container.encode(x)
1225+ case .double(let x):
1226+ try container.encode(x)
1227+ case .null:
1228+ try container.encodeNil()
1229+ }
1230+ }
1231+ }
1232+
1233+ enum PiaculumElement: Codable {
1234+ case double(Double)
1235+ case piaculumClass(TopLevel.PiaculumClass)
1236+
1237+ init(from decoder: Decoder) throws {
1238+ let container = try decoder.singleValueContainer()
1239+ if let x = try? container.decode(Double.self) {
1240+ self = .double(x)
1241+ return
1242+ }
1243+ if let x = try? container.decode(TopLevel.PiaculumClass.self) {
1244+ self = .piaculumClass(x)
1245+ return
1246+ }
1247+ throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement"))
1248+ }
1249+
1250+ func encode(to encoder: Encoder) throws {
1251+ var container = encoder.singleValueContainer()
1252+ switch self {
1253+ case .double(let x):
1254+ try container.encode(x)
1255+ case .piaculumClass(let x):
1256+ try container.encode(x)
1257+ }
1258+ }
1259+ }
1260+
1261+ struct PiaculumClass: Codable {
1262+ let alada: Int?
1263+ let amphistomous: Int?
1264+ let boysenberry: Int?
1265+ let catharticalness: Double?
1266+ let chirotherium: Int?
1267+ let decardinalize: Int?
1268+ let discouragement: Int?
1269+ let disdiapason: String?
1270+ let doitrified: Int?
1271+ let hexaspermous: Int?
1272+ let homocerc: Bool?
1273+ let insinking: Int?
1274+ let loathfulness: Int?
1275+ let miasmatical: Int?
1276+ let neurofibril: Int?
1277+ let nonbookish: JSONNull?
1278+ let phonendoscope: Int?
1279+ let pilferment: Int?
1280+ let predismissory: Int?
1281+ let preinscription: Int?
1282+ let quotative: Int?
1283+ let sienna: Int?
1284+ let thorax: Int?
1285+ let yachting: Int?
1286+ let zipper: Int?
1287+
1288+ enum CodingKeys: String, CodingKey {
1289+ case alada = "alada"
1290+ case amphistomous = "amphistomous"
1291+ case boysenberry = "boysenberry"
1292+ case catharticalness = "catharticalness"
1293+ case chirotherium = "Chirotherium"
1294+ case decardinalize = "decardinalize"
1295+ case discouragement = "discouragement"
1296+ case disdiapason = "disdiapason"
1297+ case doitrified = "doitrified"
1298+ case hexaspermous = "hexaspermous"
1299+ case homocerc = "homocerc"
1300+ case insinking = "insinking"
1301+ case loathfulness = "loathfulness"
1302+ case miasmatical = "miasmatical"
1303+ case neurofibril = "neurofibril"
1304+ case nonbookish = "nonbookish"
1305+ case phonendoscope = "phonendoscope"
1306+ case pilferment = "pilferment"
1307+ case predismissory = "predismissory"
1308+ case preinscription = "preinscription"
1309+ case quotative = "quotative"
1310+ case sienna = "sienna"
1311+ case thorax = "thorax"
1312+ case yachting = "yachting"
1313+ case zipper = "Zipper"
1314+ }
1315+ }
1316+
1317+ enum Piccadilly: Codable {
1318+ case double(Double)
1319+ case string(String)
1320+ case null
1321+
1322+ init(from decoder: Decoder) throws {
1323+ let container = try decoder.singleValueContainer()
1324+ if let x = try? container.decode(Double.self) {
1325+ self = .double(x)
1326+ return
1327+ }
1328+ if let x = try? container.decode(String.self) {
1329+ self = .string(x)
1330+ return
1331+ }
1332+ if container.decodeNil() {
1333+ self = .null
1334+ return
1335+ }
1336+ throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly"))
1337+ }
1338+
1339+ func encode(to encoder: Encoder) throws {
1340+ var container = encoder.singleValueContainer()
1341+ switch self {
1342+ case .double(let x):
1343+ try container.encode(x)
1344+ case .string(let x):
1345+ try container.encode(x)
1346+ case .null:
1347+ try container.encodeNil()
1348+ }
1349+ }
1350+ }
1351+
1352+ enum Piffler: Codable {
1353+ case monaziteClass(TopLevel.MonaziteClass)
1354+ case nullArray([JSONNull?])
1355+
1356+ init(from decoder: Decoder) throws {
1357+ let container = try decoder.singleValueContainer()
1358+ if let x = try? container.decode([JSONNull?].self) {
1359+ self = .nullArray(x)
1360+ return
1361+ }
1362+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
1363+ self = .monaziteClass(x)
1364+ return
1365+ }
1366+ throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler"))
1367+ }
1368+
1369+ func encode(to encoder: Encoder) throws {
1370+ var container = encoder.singleValueContainer()
1371+ switch self {
1372+ case .monaziteClass(let x):
1373+ try container.encode(x)
1374+ case .nullArray(let x):
1375+ try container.encode(x)
1376+ }
1377+ }
1378+ }
1379+
1380+ enum Pithful: Codable {
1381+ case bool(Bool)
1382+ case integer(Int)
1383+ case null
1384+
1385+ init(from decoder: Decoder) throws {
1386+ let container = try decoder.singleValueContainer()
1387+ if let x = try? container.decode(Bool.self) {
1388+ self = .bool(x)
1389+ return
1390+ }
1391+ if let x = try? container.decode(Int.self) {
1392+ self = .integer(x)
1393+ return
1394+ }
1395+ if container.decodeNil() {
1396+ self = .null
1397+ return
1398+ }
1399+ throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful"))
1400+ }
1401+
1402+ func encode(to encoder: Encoder) throws {
1403+ var container = encoder.singleValueContainer()
1404+ switch self {
1405+ case .bool(let x):
1406+ try container.encode(x)
1407+ case .integer(let x):
1408+ try container.encode(x)
1409+ case .null:
1410+ try container.encodeNil()
1411+ }
1412+ }
1413+ }
1414+
1415+ enum Placuntiti: Codable {
1416+ case integer(Int)
1417+ case integerMap([String: Int])
1418+
1419+ init(from decoder: Decoder) throws {
1420+ let container = try decoder.singleValueContainer()
1421+ if let x = try? container.decode(Int.self) {
1422+ self = .integer(x)
1423+ return
1424+ }
1425+ if let x = try? container.decode([String: Int].self) {
1426+ self = .integerMap(x)
1427+ return
1428+ }
1429+ throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti"))
1430+ }
1431+
1432+ func encode(to encoder: Encoder) throws {
1433+ var container = encoder.singleValueContainer()
1434+ switch self {
1435+ case .integer(let x):
1436+ try container.encode(x)
1437+ case .integerMap(let x):
1438+ try container.encode(x)
1439+ }
1440+ }
1441+ }
1442+
1443+ enum Plectopterous: Codable {
1444+ case double(Double)
1445+ case integerMap([String: Int])
1446+
1447+ init(from decoder: Decoder) throws {
1448+ let container = try decoder.singleValueContainer()
1449+ if let x = try? container.decode(Double.self) {
1450+ self = .double(x)
1451+ return
1452+ }
1453+ if let x = try? container.decode([String: Int].self) {
1454+ self = .integerMap(x)
1455+ return
1456+ }
1457+ throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous"))
1458+ }
1459+
1460+ func encode(to encoder: Encoder) throws {
1461+ var container = encoder.singleValueContainer()
1462+ switch self {
1463+ case .double(let x):
1464+ try container.encode(x)
1465+ case .integerMap(let x):
1466+ try container.encode(x)
1467+ }
1468+ }
1469+ }
1470+
1471+ struct Pneumocele: Codable {
1472+ let carbonarism: JSONNull?
1473+ let catharticalness: Double?
1474+ let chirotherium: Int?
1475+ let cineolic: JSONNull?
1476+ let cobbly: JSONNull?
1477+ let conchyliferous: JSONNull?
1478+ let congregation: JSONNull?
1479+ let disdiapason: String?
1480+ let enterotomy: JSONNull?
1481+ let entophytal: JSONNull?
1482+ let fewtrils: JSONNull?
1483+ let herem: JSONNull?
1484+ let homocerc: Bool?
1485+ let koniga: JSONNull?
1486+ let meticulosity: JSONNull?
1487+ let micky: JSONNull?
1488+ let mismarriage: JSONNull?
1489+ let neurotrophic: JSONNull?
1490+ let nonbookish: JSONNull?
1491+ let persuasively: JSONNull?
1492+ let replaceable: JSONNull?
1493+ let silex: JSONNull?
1494+ let taillight: JSONNull?
1495+ let unjealous: JSONNull?
1496+ let visitorial: JSONNull?
1497+
1498+ enum CodingKeys: String, CodingKey {
1499+ case carbonarism = "Carbonarism"
1500+ case catharticalness = "catharticalness"
1501+ case chirotherium = "Chirotherium"
1502+ case cineolic = "cineolic"
1503+ case cobbly = "cobbly"
1504+ case conchyliferous = "conchyliferous"
1505+ case congregation = "congregation"
1506+ case disdiapason = "disdiapason"
1507+ case enterotomy = "enterotomy"
1508+ case entophytal = "entophytal"
1509+ case fewtrils = "fewtrils"
1510+ case herem = "herem"
1511+ case homocerc = "homocerc"
1512+ case koniga = "Koniga"
1513+ case meticulosity = "meticulosity"
1514+ case micky = "Micky"
1515+ case mismarriage = "mismarriage"
1516+ case neurotrophic = "neurotrophic"
1517+ case nonbookish = "nonbookish"
1518+ case persuasively = "persuasively"
1519+ case replaceable = "replaceable"
1520+ case silex = "silex"
1521+ case taillight = "taillight"
1522+ case unjealous = "unjealous"
1523+ case visitorial = "visitorial"
1524+ }
1525+ }
1526+
1527+ enum Poliorcetic: Codable {
1528+ case bool(Bool)
1529+ case monaziteClass(TopLevel.MonaziteClass)
1530+
1531+ init(from decoder: Decoder) throws {
1532+ let container = try decoder.singleValueContainer()
1533+ if let x = try? container.decode(Bool.self) {
1534+ self = .bool(x)
1535+ return
1536+ }
1537+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
1538+ self = .monaziteClass(x)
1539+ return
1540+ }
1541+ throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic"))
1542+ }
1543+
1544+ func encode(to encoder: Encoder) throws {
1545+ var container = encoder.singleValueContainer()
1546+ switch self {
1547+ case .bool(let x):
1548+ try container.encode(x)
1549+ case .monaziteClass(let x):
1550+ try container.encode(x)
1551+ }
1552+ }
1553+ }
1554+
1555+ enum Poormaster: Codable {
1556+ case integerArray([Int])
1557+ case integerMap([String: Int])
1558+ case null
1559+
1560+ init(from decoder: Decoder) throws {
1561+ let container = try decoder.singleValueContainer()
1562+ if let x = try? container.decode([Int].self) {
1563+ self = .integerArray(x)
1564+ return
1565+ }
1566+ if let x = try? container.decode([String: Int].self) {
1567+ self = .integerMap(x)
1568+ return
1569+ }
1570+ if container.decodeNil() {
1571+ self = .null
1572+ return
1573+ }
1574+ throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster"))
1575+ }
1576+
1577+ func encode(to encoder: Encoder) throws {
1578+ var container = encoder.singleValueContainer()
1579+ switch self {
1580+ case .integerArray(let x):
1581+ try container.encode(x)
1582+ case .integerMap(let x):
1583+ try container.encode(x)
1584+ case .null:
1585+ try container.encodeNil()
1586+ }
1587+ }
1588+ }
1589+
1590+ enum PotwhiskyElement: Codable {
1591+ case integer(Int)
1592+ case potwhiskyClass(TopLevel.PotwhiskyClass)
1593+ case null
1594+
1595+ init(from decoder: Decoder) throws {
1596+ let container = try decoder.singleValueContainer()
1597+ if let x = try? container.decode(Int.self) {
1598+ self = .integer(x)
1599+ return
1600+ }
1601+ if let x = try? container.decode(TopLevel.PotwhiskyClass.self) {
1602+ self = .potwhiskyClass(x)
1603+ return
1604+ }
1605+ if container.decodeNil() {
1606+ self = .null
1607+ return
1608+ }
1609+ throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement"))
1610+ }
1611+
1612+ func encode(to encoder: Encoder) throws {
1613+ var container = encoder.singleValueContainer()
1614+ switch self {
1615+ case .integer(let x):
1616+ try container.encode(x)
1617+ case .potwhiskyClass(let x):
1618+ try container.encode(x)
1619+ case .null:
1620+ try container.encodeNil()
1621+ }
1622+ }
1623+ }
1624+
1625+ struct PotwhiskyClass: Codable {
1626+ let arciform: JSONNull?
1627+ let cresolin: JSONNull?
1628+ let disheartener: JSONNull?
1629+ let disproportionable: JSONNull?
1630+ let euchorda: JSONNull?
1631+ let ferryway: JSONNull?
1632+ let filamentiferous: JSONNull?
1633+ let flemish: JSONNull?
1634+ let forgainst: JSONNull?
1635+ let grainering: JSONNull?
1636+ let irrevoluble: JSONNull?
1637+ let kindredship: JSONNull?
1638+ let pinguitudinous: JSONNull?
1639+ let simpletonic: JSONNull?
1640+ let singsong: JSONNull?
1641+ let submergement: JSONNull?
1642+ let supraoesophagal: JSONNull?
1643+ let thrashel: JSONNull?
1644+ let tyremesis: JSONNull?
1645+ let yoruba: JSONNull?
1646+
1647+ enum CodingKeys: String, CodingKey {
1648+ case arciform = "arciform"
1649+ case cresolin = "cresolin"
1650+ case disheartener = "disheartener"
1651+ case disproportionable = "disproportionable"
1652+ case euchorda = "Euchorda"
1653+ case ferryway = "ferryway"
1654+ case filamentiferous = "filamentiferous"
1655+ case flemish = "flemish"
1656+ case forgainst = "forgainst"
1657+ case grainering = "grainering"
1658+ case irrevoluble = "irrevoluble"
1659+ case kindredship = "kindredship"
1660+ case pinguitudinous = "pinguitudinous"
1661+ case simpletonic = "simpletonic"
1662+ case singsong = "singsong"
1663+ case submergement = "submergement"
1664+ case supraoesophagal = "supraoesophagal"
1665+ case thrashel = "thrashel"
1666+ case tyremesis = "tyremesis"
1667+ case yoruba = "Yoruba"
1668+ }
1669+ }
1670+
1671+ enum Practicalizer: Codable {
1672+ case monaziteClass(TopLevel.MonaziteClass)
1673+ case nullArray([JSONNull?])
1674+ case string(String)
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(String.self) {
1683+ self = .string(x)
1684+ return
1685+ }
1686+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
1687+ self = .monaziteClass(x)
1688+ return
1689+ }
1690+ throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer"))
1691+ }
1692+
1693+ func encode(to encoder: Encoder) throws {
1694+ var container = encoder.singleValueContainer()
1695+ switch self {
1696+ case .monaziteClass(let x):
1697+ try container.encode(x)
1698+ case .nullArray(let x):
1699+ try container.encode(x)
1700+ case .string(let x):
1701+ try container.encode(x)
1702+ }
1703+ }
1704+ }
1705+
1706+ enum PrefreshmanElement: Codable {
1707+ case nullArray([JSONNull?])
1708+ case prefreshmanClass(TopLevel.PrefreshmanClass)
1709+ case string(String)
1710+
1711+ init(from decoder: Decoder) throws {
1712+ let container = try decoder.singleValueContainer()
1713+ if let x = try? container.decode([JSONNull?].self) {
1714+ self = .nullArray(x)
1715+ return
1716+ }
1717+ if let x = try? container.decode(String.self) {
1718+ self = .string(x)
1719+ return
1720+ }
1721+ if let x = try? container.decode(TopLevel.PrefreshmanClass.self) {
1722+ self = .prefreshmanClass(x)
1723+ return
1724+ }
1725+ throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement"))
1726+ }
1727+
1728+ func encode(to encoder: Encoder) throws {
1729+ var container = encoder.singleValueContainer()
1730+ switch self {
1731+ case .nullArray(let x):
1732+ try container.encode(x)
1733+ case .prefreshmanClass(let x):
1734+ try container.encode(x)
1735+ case .string(let x):
1736+ try container.encode(x)
1737+ }
1738+ }
1739+ }
1740+
1741+ struct PrefreshmanClass: Codable {
1742+ let azorubine: JSONNull?
1743+ let choroiditis: JSONNull?
1744+ let coagulatory: JSONNull?
1745+ let cyclorama: JSONNull?
1746+ let dolphus: JSONNull?
1747+ let duckhearted: JSONNull?
1748+ let ficus: JSONNull?
1749+ let gemaric: JSONNull?
1750+ let jugation: JSONNull?
1751+ let myoliposis: JSONNull?
1752+ let nonnomination: JSONNull?
1753+ let palay: JSONNull?
1754+ let pentactinal: JSONNull?
1755+ let phaet: JSONNull?
1756+ let piquant: JSONNull?
1757+ let registration: JSONNull?
1758+ let remancipation: JSONNull?
1759+ let scutatiform: JSONNull?
1760+ let theodolite: JSONNull?
1761+ let underward: JSONNull?
1762+
1763+ enum CodingKeys: String, CodingKey {
1764+ case azorubine = "azorubine"
1765+ case choroiditis = "choroiditis"
1766+ case coagulatory = "coagulatory"
1767+ case cyclorama = "cyclorama"
1768+ case dolphus = "Dolphus"
1769+ case duckhearted = "duckhearted"
1770+ case ficus = "Ficus"
1771+ case gemaric = "Gemaric"
1772+ case jugation = "jugation"
1773+ case myoliposis = "myoliposis"
1774+ case nonnomination = "nonnomination"
1775+ case palay = "palay"
1776+ case pentactinal = "pentactinal"
1777+ case phaet = "Phaet"
1778+ case piquant = "piquant"
1779+ case registration = "registration"
1780+ case remancipation = "remancipation"
1781+ case scutatiform = "scutatiform"
1782+ case theodolite = "theodolite"
1783+ case underward = "underward"
1784+ }
1785+ }
1786+
1787+ enum Prehensility: Codable {
1788+ case bool(Bool)
1789+ case monaziteClass(TopLevel.MonaziteClass)
1790+ case nullArray([JSONNull?])
1791+
1792+ init(from decoder: Decoder) throws {
1793+ let container = try decoder.singleValueContainer()
1794+ if let x = try? container.decode(Bool.self) {
1795+ self = .bool(x)
1796+ return
1797+ }
1798+ if let x = try? container.decode([JSONNull?].self) {
1799+ self = .nullArray(x)
1800+ return
1801+ }
1802+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
1803+ self = .monaziteClass(x)
1804+ return
1805+ }
1806+ throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility"))
1807+ }
1808+
1809+ func encode(to encoder: Encoder) throws {
1810+ var container = encoder.singleValueContainer()
1811+ switch self {
1812+ case .bool(let x):
1813+ try container.encode(x)
1814+ case .monaziteClass(let x):
1815+ try container.encode(x)
1816+ case .nullArray(let x):
1817+ try container.encode(x)
1818+ }
1819+ }
1820+ }
1821+
1822+ enum Prevoidance: Codable {
1823+ case integer(Int)
1824+ case integerArray([Int])
1825+ case monaziteClass(TopLevel.MonaziteClass)
1826+
1827+ init(from decoder: Decoder) throws {
1828+ let container = try decoder.singleValueContainer()
1829+ if let x = try? container.decode(Int.self) {
1830+ self = .integer(x)
1831+ return
1832+ }
1833+ if let x = try? container.decode([Int].self) {
1834+ self = .integerArray(x)
1835+ return
1836+ }
1837+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
1838+ self = .monaziteClass(x)
1839+ return
1840+ }
1841+ throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance"))
1842+ }
1843+
1844+ func encode(to encoder: Encoder) throws {
1845+ var container = encoder.singleValueContainer()
1846+ switch self {
1847+ case .integer(let x):
1848+ try container.encode(x)
1849+ case .integerArray(let x):
1850+ try container.encode(x)
1851+ case .monaziteClass(let x):
1852+ try container.encode(x)
1853+ }
1854+ }
1855+ }
1856+
1857+ enum Protext: Codable {
1858+ case bool(Bool)
1859+ case integerArray([Int])
1860+ case monaziteClass(TopLevel.MonaziteClass)
1861+
1862+ init(from decoder: Decoder) throws {
1863+ let container = try decoder.singleValueContainer()
1864+ if let x = try? container.decode(Bool.self) {
1865+ self = .bool(x)
1866+ return
1867+ }
1868+ if let x = try? container.decode([Int].self) {
1869+ self = .integerArray(x)
1870+ return
1871+ }
1872+ if let x = try? container.decode(TopLevel.MonaziteClass.self) {
1873+ self = .monaziteClass(x)
1874+ return
1875+ }
1876+ throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext"))
1877+ }
1878+
1879+ func encode(to encoder: Encoder) throws {
1880+ var container = encoder.singleValueContainer()
1881+ switch self {
1882+ case .bool(let x):
1883+ try container.encode(x)
1884+ case .integerArray(let x):
1885+ try container.encode(x)
1886+ case .monaziteClass(let x):
1887+ try container.encode(x)
1888+ }
1889+ }
1890+ }
1891+}
1892+
1893+// MARK: TopLevel convenience initializers and mutators
1894+
1895+extension TopLevel {
1896+ init(data: Data) throws {
1897+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
1898+ }
1899+
1900+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1901+ guard let data = json.data(using: encoding) else {
1902+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1903+ }
1904+ try self.init(data: data)
1905+ }
1906+
1907+ init(fromURL url: URL) throws {
1908+ try self.init(data: try Data(contentsOf: url))
1909+ }
1910+
1911+ func with(
1912+ juror: [TopLevel.JurorElement]? = nil,
1913+ kongoni: [TopLevel.Kongoni]? = nil,
1914+ ladronism: [TopLevel.LadronismElement]? = nil,
1915+ landlubberly: [TopLevel.LandlubberlyElement]? = nil,
1916+ listener: [TopLevel.Listener]? = nil,
1917+ lupus: [TopLevel.LupusElement]? = nil,
1918+ maslin: [TopLevel.Maslin]? = nil,
1919+ monazite: [TopLevel.MonaziteElement]? = nil,
1920+ monoliteral: [TopLevel.Monoliteral]? = nil,
1921+ monotheistically: [TopLevel.MonotheisticallyElement]? = nil,
1922+ montage: [TopLevel.Montage]? = nil,
1923+ moralness: [TopLevel.Moralness]? = nil,
1924+ mowra: [TopLevel.MonaziteClass?]? = nil,
1925+ mulishly: [TopLevel.Mulishly]? = nil,
1926+ myoscope: [TopLevel.Myoscope]? = nil,
1927+ nach: [[Int?]?]? = nil,
1928+ neuromastic: [TopLevel.Neuromastic]? = nil,
1929+ noncontributing: [TopLevel.Noncontributing]? = nil,
1930+ nonnervous: [TopLevel.Nonnervous]? = nil,
1931+ nonvaluation: [TopLevel.Nonvaluation]? = nil,
1932+ occupationalist: [TopLevel.OccupationalistElement]? = nil,
1933+ outrival: [TopLevel.OutrivalElement]? = nil,
1934+ paleographically: [TopLevel.Paleographically]? = nil,
1935+ pamphletwise: [TopLevel.Pamphletwise]? = nil,
1936+ pediatrics: [TopLevel.Pediatric]? = nil,
1937+ perceptive: [Bool]? = nil,
1938+ piaculum: [TopLevel.PiaculumElement]? = nil,
1939+ piccadilly: [TopLevel.Piccadilly]? = nil,
1940+ piffler: [TopLevel.Piffler]? = nil,
1941+ pithful: [TopLevel.Pithful]? = nil,
1942+ placuntitis: [TopLevel.Placuntiti]? = nil,
1943+ plectopterous: [TopLevel.Plectopterous]? = nil,
1944+ pneumocele: [TopLevel.Pneumocele?]? = nil,
1945+ poliorcetic: [TopLevel.Poliorcetic]? = nil,
1946+ poormaster: [TopLevel.Poormaster]? = nil,
1947+ potwhisky: [TopLevel.PotwhiskyElement]? = nil,
1948+ practicalizer: [TopLevel.Practicalizer]? = nil,
1949+ prefreshman: [TopLevel.PrefreshmanElement]? = nil,
1950+ prehensility: [TopLevel.Prehensility]? = nil,
1951+ prevoidance: [TopLevel.Prevoidance]? = nil,
1952+ probant: [[String: Int?]]? = nil,
1953+ protext: [TopLevel.Protext]? = nil
1954+ ) -> TopLevel {
1955+ return TopLevel(
1956+ juror: juror ?? self.juror,
1957+ kongoni: kongoni ?? self.kongoni,
1958+ ladronism: ladronism ?? self.ladronism,
1959+ landlubberly: landlubberly ?? self.landlubberly,
1960+ listener: listener ?? self.listener,
1961+ lupus: lupus ?? self.lupus,
1962+ maslin: maslin ?? self.maslin,
1963+ monazite: monazite ?? self.monazite,
1964+ monoliteral: monoliteral ?? self.monoliteral,
1965+ monotheistically: monotheistically ?? self.monotheistically,
1966+ montage: montage ?? self.montage,
1967+ moralness: moralness ?? self.moralness,
1968+ mowra: mowra ?? self.mowra,
1969+ mulishly: mulishly ?? self.mulishly,
1970+ myoscope: myoscope ?? self.myoscope,
1971+ nach: nach ?? self.nach,
1972+ neuromastic: neuromastic ?? self.neuromastic,
1973+ noncontributing: noncontributing ?? self.noncontributing,
1974+ nonnervous: nonnervous ?? self.nonnervous,
1975+ nonvaluation: nonvaluation ?? self.nonvaluation,
1976+ occupationalist: occupationalist ?? self.occupationalist,
1977+ outrival: outrival ?? self.outrival,
1978+ paleographically: paleographically ?? self.paleographically,
1979+ pamphletwise: pamphletwise ?? self.pamphletwise,
1980+ pediatrics: pediatrics ?? self.pediatrics,
1981+ perceptive: perceptive ?? self.perceptive,
1982+ piaculum: piaculum ?? self.piaculum,
1983+ piccadilly: piccadilly ?? self.piccadilly,
1984+ piffler: piffler ?? self.piffler,
1985+ pithful: pithful ?? self.pithful,
1986+ placuntitis: placuntitis ?? self.placuntitis,
1987+ plectopterous: plectopterous ?? self.plectopterous,
1988+ pneumocele: pneumocele ?? self.pneumocele,
1989+ poliorcetic: poliorcetic ?? self.poliorcetic,
1990+ poormaster: poormaster ?? self.poormaster,
1991+ potwhisky: potwhisky ?? self.potwhisky,
1992+ practicalizer: practicalizer ?? self.practicalizer,
1993+ prefreshman: prefreshman ?? self.prefreshman,
1994+ prehensility: prehensility ?? self.prehensility,
1995+ prevoidance: prevoidance ?? self.prevoidance,
1996+ probant: probant ?? self.probant,
1997+ protext: protext ?? self.protext
1998+ )
1999+ }
2000+
2001+ func jsonData() throws -> Data {
2002+ return try newJSONEncoder().encode(self)
2003+ }
2004+
2005+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2006+ return String(data: try self.jsonData(), encoding: encoding)
2007+ }
2008+}
2009+
2010+extension TopLevel.JurorClass {
2011+ init(data: Data) throws {
2012+ self = try newJSONDecoder().decode(TopLevel.JurorClass.self, from: data)
2013+ }
2014+
2015+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2016+ guard let data = json.data(using: encoding) else {
2017+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2018+ }
2019+ try self.init(data: data)
2020+ }
2021+
2022+ init(fromURL url: URL) throws {
2023+ try self.init(data: try Data(contentsOf: url))
2024+ }
2025+
2026+ func with(
2027+ adipsy: JSONNull?? = nil,
2028+ auxiliator: JSONNull?? = nil,
2029+ benda: JSONNull?? = nil,
2030+ benjamin: JSONNull?? = nil,
2031+ brandling: JSONNull?? = nil,
2032+ epicurishly: JSONNull?? = nil,
2033+ eremochaetous: JSONNull?? = nil,
2034+ marten: JSONNull?? = nil,
2035+ monocline: JSONNull?? = nil,
2036+ olea: JSONNull?? = nil,
2037+ palgat: JSONNull?? = nil,
2038+ pennyworth: JSONNull?? = nil,
2039+ pioury: JSONNull?? = nil,
2040+ pragmatistic: JSONNull?? = nil,
2041+ stylelessness: JSONNull?? = nil,
2042+ systematical: JSONNull?? = nil,
2043+ thready: JSONNull?? = nil,
2044+ uncontemporary: JSONNull?? = nil,
2045+ uncouched: JSONNull?? = nil,
2046+ uninhabitedness: JSONNull?? = nil
2047+ ) -> TopLevel.JurorClass {
2048+ return TopLevel.JurorClass(
2049+ adipsy: adipsy ?? self.adipsy,
2050+ auxiliator: auxiliator ?? self.auxiliator,
2051+ benda: benda ?? self.benda,
2052+ benjamin: benjamin ?? self.benjamin,
2053+ brandling: brandling ?? self.brandling,
2054+ epicurishly: epicurishly ?? self.epicurishly,
2055+ eremochaetous: eremochaetous ?? self.eremochaetous,
2056+ marten: marten ?? self.marten,
2057+ monocline: monocline ?? self.monocline,
2058+ olea: olea ?? self.olea,
2059+ palgat: palgat ?? self.palgat,
2060+ pennyworth: pennyworth ?? self.pennyworth,
2061+ pioury: pioury ?? self.pioury,
2062+ pragmatistic: pragmatistic ?? self.pragmatistic,
2063+ stylelessness: stylelessness ?? self.stylelessness,
2064+ systematical: systematical ?? self.systematical,
2065+ thready: thready ?? self.thready,
2066+ uncontemporary: uncontemporary ?? self.uncontemporary,
2067+ uncouched: uncouched ?? self.uncouched,
2068+ uninhabitedness: uninhabitedness ?? self.uninhabitedness
2069+ )
2070+ }
2071+
2072+ func jsonData() throws -> Data {
2073+ return try newJSONEncoder().encode(self)
2074+ }
2075+
2076+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2077+ return String(data: try self.jsonData(), encoding: encoding)
2078+ }
2079+}
2080+
2081+extension TopLevel.LadronismClass {
2082+ init(data: Data) throws {
2083+ self = try newJSONDecoder().decode(TopLevel.LadronismClass.self, from: data)
2084+ }
2085+
2086+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2087+ guard let data = json.data(using: encoding) else {
2088+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2089+ }
2090+ try self.init(data: data)
2091+ }
2092+
2093+ init(fromURL url: URL) throws {
2094+ try self.init(data: try Data(contentsOf: url))
2095+ }
2096+
2097+ func with(
2098+ acclaimer: JSONNull?? = nil,
2099+ achree: JSONNull?? = nil,
2100+ base: JSONNull?? = nil,
2101+ conundrumize: JSONNull?? = nil,
2102+ degerminator: JSONNull?? = nil,
2103+ describable: JSONNull?? = nil,
2104+ exasperatedly: JSONNull?? = nil,
2105+ heroine: JSONNull?? = nil,
2106+ indazin: JSONNull?? = nil,
2107+ luteous: JSONNull?? = nil,
2108+ papular: JSONNull?? = nil,
2109+ pritch: JSONNull?? = nil,
2110+ prodenia: JSONNull?? = nil,
2111+ seege: JSONNull?? = nil,
2112+ shopgirl: JSONNull?? = nil,
2113+ tragedietta: JSONNull?? = nil,
2114+ unsparse: JSONNull?? = nil,
2115+ uplook: JSONNull?? = nil,
2116+ vermiformis: JSONNull?? = nil,
2117+ whafabout: JSONNull?? = nil
2118+ ) -> TopLevel.LadronismClass {
2119+ return TopLevel.LadronismClass(
2120+ acclaimer: acclaimer ?? self.acclaimer,
2121+ achree: achree ?? self.achree,
2122+ base: base ?? self.base,
2123+ conundrumize: conundrumize ?? self.conundrumize,
2124+ degerminator: degerminator ?? self.degerminator,
2125+ describable: describable ?? self.describable,
2126+ exasperatedly: exasperatedly ?? self.exasperatedly,
2127+ heroine: heroine ?? self.heroine,
2128+ indazin: indazin ?? self.indazin,
2129+ luteous: luteous ?? self.luteous,
2130+ papular: papular ?? self.papular,
2131+ pritch: pritch ?? self.pritch,
2132+ prodenia: prodenia ?? self.prodenia,
2133+ seege: seege ?? self.seege,
2134+ shopgirl: shopgirl ?? self.shopgirl,
2135+ tragedietta: tragedietta ?? self.tragedietta,
2136+ unsparse: unsparse ?? self.unsparse,
2137+ uplook: uplook ?? self.uplook,
2138+ vermiformis: vermiformis ?? self.vermiformis,
2139+ whafabout: whafabout ?? self.whafabout
2140+ )
2141+ }
2142+
2143+ func jsonData() throws -> Data {
2144+ return try newJSONEncoder().encode(self)
2145+ }
2146+
2147+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2148+ return String(data: try self.jsonData(), encoding: encoding)
2149+ }
2150+}
2151+
2152+extension TopLevel.LandlubberlyClass {
2153+ init(data: Data) throws {
2154+ self = try newJSONDecoder().decode(TopLevel.LandlubberlyClass.self, from: data)
2155+ }
2156+
2157+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2158+ guard let data = json.data(using: encoding) else {
2159+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2160+ }
2161+ try self.init(data: data)
2162+ }
2163+
2164+ init(fromURL url: URL) throws {
2165+ try self.init(data: try Data(contentsOf: url))
2166+ }
2167+
2168+ func with(
2169+ acropoleis: JSONNull?? = nil,
2170+ aminate: JSONNull?? = nil,
2171+ amyraldism: JSONNull?? = nil,
2172+ bipenniform: JSONNull?? = nil,
2173+ bugre: JSONNull?? = nil,
2174+ calycule: JSONNull?? = nil,
2175+ caoutchouc: JSONNull?? = nil,
2176+ disprover: JSONNull?? = nil,
2177+ fitroot: JSONNull?? = nil,
2178+ fulgently: JSONNull?? = nil,
2179+ kickup: JSONNull?? = nil,
2180+ laevoversion: JSONNull?? = nil,
2181+ moter: JSONNull?? = nil,
2182+ objectivity: JSONNull?? = nil,
2183+ posterity: JSONNull?? = nil,
2184+ postnuptial: JSONNull?? = nil,
2185+ precedentary: JSONNull?? = nil,
2186+ saddling: JSONNull?? = nil,
2187+ subcurrent: JSONNull?? = nil,
2188+ unrecriminative: JSONNull?? = nil
2189+ ) -> TopLevel.LandlubberlyClass {
2190+ return TopLevel.LandlubberlyClass(
2191+ acropoleis: acropoleis ?? self.acropoleis,
2192+ aminate: aminate ?? self.aminate,
2193+ amyraldism: amyraldism ?? self.amyraldism,
2194+ bipenniform: bipenniform ?? self.bipenniform,
2195+ bugre: bugre ?? self.bugre,
2196+ calycule: calycule ?? self.calycule,
2197+ caoutchouc: caoutchouc ?? self.caoutchouc,
2198+ disprover: disprover ?? self.disprover,
2199+ fitroot: fitroot ?? self.fitroot,
2200+ fulgently: fulgently ?? self.fulgently,
2201+ kickup: kickup ?? self.kickup,
2202+ laevoversion: laevoversion ?? self.laevoversion,
2203+ moter: moter ?? self.moter,
2204+ objectivity: objectivity ?? self.objectivity,
2205+ posterity: posterity ?? self.posterity,
2206+ postnuptial: postnuptial ?? self.postnuptial,
2207+ precedentary: precedentary ?? self.precedentary,
2208+ saddling: saddling ?? self.saddling,
2209+ subcurrent: subcurrent ?? self.subcurrent,
2210+ unrecriminative: unrecriminative ?? self.unrecriminative
2211+ )
2212+ }
2213+
2214+ func jsonData() throws -> Data {
2215+ return try newJSONEncoder().encode(self)
2216+ }
2217+
2218+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2219+ return String(data: try self.jsonData(), encoding: encoding)
2220+ }
2221+}
2222+
2223+extension TopLevel.LupusClass {
2224+ init(data: Data) throws {
2225+ self = try newJSONDecoder().decode(TopLevel.LupusClass.self, from: data)
2226+ }
2227+
2228+ 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+ init(fromURL url: URL) throws {
2236+ try self.init(data: try Data(contentsOf: url))
2237+ }
2238+
2239+ func with(
2240+ catharticalness: Double?? = nil,
2241+ chirotherium: Int?? = nil,
2242+ chlorioninae: Int?? = nil,
2243+ corvinae: Int?? = nil,
2244+ crassina: Int?? = nil,
2245+ disdiapason: String?? = nil,
2246+ exiguity: Int?? = nil,
2247+ farcist: Int?? = nil,
2248+ holographical: Int?? = nil,
2249+ homocerc: Bool?? = nil,
2250+ ichthyophagan: Int?? = nil,
2251+ implacable: Int?? = nil,
2252+ nonbookish: JSONNull?? = nil,
2253+ outshiner: Int?? = nil,
2254+ overweather: Int?? = nil,
2255+ protonegroid: Int?? = nil,
2256+ shallowish: Int?? = nil,
2257+ snoke: Int?? = nil,
2258+ snout: Int?? = nil,
2259+ surveillance: Int?? = nil,
2260+ threshingtime: Int?? = nil,
2261+ thysanocarpus: Int?? = nil,
2262+ unsignificantly: Int?? = nil,
2263+ unsnap: Int?? = nil,
2264+ vendible: Int?? = nil
2265+ ) -> TopLevel.LupusClass {
2266+ return TopLevel.LupusClass(
2267+ catharticalness: catharticalness ?? self.catharticalness,
2268+ chirotherium: chirotherium ?? self.chirotherium,
2269+ chlorioninae: chlorioninae ?? self.chlorioninae,
2270+ corvinae: corvinae ?? self.corvinae,
2271+ crassina: crassina ?? self.crassina,
2272+ disdiapason: disdiapason ?? self.disdiapason,
2273+ exiguity: exiguity ?? self.exiguity,
2274+ farcist: farcist ?? self.farcist,
2275+ holographical: holographical ?? self.holographical,
2276+ homocerc: homocerc ?? self.homocerc,
2277+ ichthyophagan: ichthyophagan ?? self.ichthyophagan,
2278+ implacable: implacable ?? self.implacable,
2279+ nonbookish: nonbookish ?? self.nonbookish,
2280+ outshiner: outshiner ?? self.outshiner,
2281+ overweather: overweather ?? self.overweather,
2282+ protonegroid: protonegroid ?? self.protonegroid,
2283+ shallowish: shallowish ?? self.shallowish,
2284+ snoke: snoke ?? self.snoke,
2285+ snout: snout ?? self.snout,
2286+ surveillance: surveillance ?? self.surveillance,
2287+ threshingtime: threshingtime ?? self.threshingtime,
2288+ thysanocarpus: thysanocarpus ?? self.thysanocarpus,
2289+ unsignificantly: unsignificantly ?? self.unsignificantly,
2290+ unsnap: unsnap ?? self.unsnap,
2291+ vendible: vendible ?? self.vendible
2292+ )
2293+ }
2294+
2295+ func jsonData() throws -> Data {
2296+ return try newJSONEncoder().encode(self)
2297+ }
2298+
2299+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2300+ return String(data: try self.jsonData(), encoding: encoding)
2301+ }
2302+}
2303+
2304+extension TopLevel.Maslin {
2305+ init(data: Data) throws {
2306+ self = try newJSONDecoder().decode(TopLevel.Maslin.self, from: data)
2307+ }
2308+
2309+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2310+ guard let data = json.data(using: encoding) else {
2311+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2312+ }
2313+ try self.init(data: data)
2314+ }
2315+
2316+ init(fromURL url: URL) throws {
2317+ try self.init(data: try Data(contentsOf: url))
2318+ }
2319+
2320+ func with(
2321+ alicant: Int?? = nil,
2322+ antiatonement: JSONNull?? = nil,
2323+ anticorrosive: Int?? = nil,
2324+ aphidozer: JSONNull?? = nil,
2325+ bakuninist: JSONNull?? = nil,
2326+ be: Int?? = nil,
2327+ catharticalness: Double?? = nil,
2328+ chirotherium: Int?? = nil,
2329+ chub: Int?? = nil,
2330+ cuprosilicon: Int?? = nil,
2331+ curtailedly: Int?? = nil,
2332+ dellenite: Int?? = nil,
2333+ dimitry: Int?? = nil,
2334+ disdiapason: String?? = nil,
2335+ edifying: JSONNull?? = nil,
2336+ ethmoiditis: Int?? = nil,
2337+ gastralgy: JSONNull?? = nil,
2338+ goatherd: Int?? = nil,
2339+ hammerdress: Int?? = nil,
2340+ hangfire: JSONNull?? = nil,
2341+ homocerc: Bool?? = nil,
2342+ lacunosity: Int?? = nil,
2343+ longiloquence: JSONNull?? = nil,
2344+ mameliere: Int?? = nil,
2345+ motherless: JSONNull?? = nil,
2346+ nonbookish: JSONNull?? = nil,
2347+ noncorrodible: JSONNull?? = nil,
2348+ nonsensicality: JSONNull?? = nil,
2349+ oafishly: Int?? = nil,
2350+ pfund: JSONNull?? = nil,
2351+ preadvisory: JSONNull?? = nil,
2352+ retroflexed: JSONNull?? = nil,
2353+ saccharulmic: Int?? = nil,
2354+ scowlful: Int?? = nil,
2355+ secluded: JSONNull?? = nil,
2356+ slackage: JSONNull?? = nil,
2357+ sphaeridial: Int?? = nil,
2358+ spondulics: JSONNull?? = nil,
2359+ subsecive: Int?? = nil,
2360+ swellmobsman: JSONNull?? = nil,
2361+ trachyglossate: Int?? = nil,
2362+ trialogue: JSONNull?? = nil,
2363+ unassuaged: Int?? = nil,
2364+ ungross: JSONNull?? = nil,
2365+ unjudiciously: JSONNull?? = nil
2366+ ) -> TopLevel.Maslin {
2367+ return TopLevel.Maslin(
2368+ alicant: alicant ?? self.alicant,
2369+ antiatonement: antiatonement ?? self.antiatonement,
2370+ anticorrosive: anticorrosive ?? self.anticorrosive,
2371+ aphidozer: aphidozer ?? self.aphidozer,
2372+ bakuninist: bakuninist ?? self.bakuninist,
2373+ be: be ?? self.be,
2374+ catharticalness: catharticalness ?? self.catharticalness,
2375+ chirotherium: chirotherium ?? self.chirotherium,
2376+ chub: chub ?? self.chub,
2377+ cuprosilicon: cuprosilicon ?? self.cuprosilicon,
2378+ curtailedly: curtailedly ?? self.curtailedly,
2379+ dellenite: dellenite ?? self.dellenite,
2380+ dimitry: dimitry ?? self.dimitry,
2381+ disdiapason: disdiapason ?? self.disdiapason,
2382+ edifying: edifying ?? self.edifying,
2383+ ethmoiditis: ethmoiditis ?? self.ethmoiditis,
2384+ gastralgy: gastralgy ?? self.gastralgy,
2385+ goatherd: goatherd ?? self.goatherd,
2386+ hammerdress: hammerdress ?? self.hammerdress,
2387+ hangfire: hangfire ?? self.hangfire,
2388+ homocerc: homocerc ?? self.homocerc,
2389+ lacunosity: lacunosity ?? self.lacunosity,
2390+ longiloquence: longiloquence ?? self.longiloquence,
2391+ mameliere: mameliere ?? self.mameliere,
2392+ motherless: motherless ?? self.motherless,
2393+ nonbookish: nonbookish ?? self.nonbookish,
2394+ noncorrodible: noncorrodible ?? self.noncorrodible,
2395+ nonsensicality: nonsensicality ?? self.nonsensicality,
2396+ oafishly: oafishly ?? self.oafishly,
2397+ pfund: pfund ?? self.pfund,
2398+ preadvisory: preadvisory ?? self.preadvisory,
2399+ retroflexed: retroflexed ?? self.retroflexed,
2400+ saccharulmic: saccharulmic ?? self.saccharulmic,
2401+ scowlful: scowlful ?? self.scowlful,
2402+ secluded: secluded ?? self.secluded,
2403+ slackage: slackage ?? self.slackage,
2404+ sphaeridial: sphaeridial ?? self.sphaeridial,
2405+ spondulics: spondulics ?? self.spondulics,
2406+ subsecive: subsecive ?? self.subsecive,
2407+ swellmobsman: swellmobsman ?? self.swellmobsman,
2408+ trachyglossate: trachyglossate ?? self.trachyglossate,
2409+ trialogue: trialogue ?? self.trialogue,
2410+ unassuaged: unassuaged ?? self.unassuaged,
2411+ ungross: ungross ?? self.ungross,
2412+ unjudiciously: unjudiciously ?? self.unjudiciously
2413+ )
2414+ }
2415+
2416+ func jsonData() throws -> Data {
2417+ return try newJSONEncoder().encode(self)
2418+ }
2419+
2420+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2421+ return String(data: try self.jsonData(), encoding: encoding)
2422+ }
2423+}
2424+
2425+extension TopLevel.MonaziteClass {
2426+ init(data: Data) throws {
2427+ self = try newJSONDecoder().decode(TopLevel.MonaziteClass.self, from: data)
2428+ }
2429+
2430+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2431+ guard let data = json.data(using: encoding) else {
2432+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2433+ }
2434+ try self.init(data: data)
2435+ }
2436+
2437+ init(fromURL url: URL) throws {
2438+ try self.init(data: try Data(contentsOf: url))
2439+ }
2440+
2441+ func with(
2442+ catharticalness: Double? = nil,
2443+ chirotherium: Int? = nil,
2444+ disdiapason: String? = nil,
2445+ homocerc: Bool? = nil,
2446+ nonbookish: JSONNull?? = nil
2447+ ) -> TopLevel.MonaziteClass {
2448+ return TopLevel.MonaziteClass(
2449+ catharticalness: catharticalness ?? self.catharticalness,
2450+ chirotherium: chirotherium ?? self.chirotherium,
2451+ disdiapason: disdiapason ?? self.disdiapason,
2452+ homocerc: homocerc ?? self.homocerc,
2453+ nonbookish: nonbookish ?? self.nonbookish
2454+ )
2455+ }
2456+
2457+ func jsonData() throws -> Data {
2458+ return try newJSONEncoder().encode(self)
2459+ }
2460+
2461+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2462+ return String(data: try self.jsonData(), encoding: encoding)
2463+ }
2464+}
2465+
2466+extension TopLevel.MonotheisticallyClass {
2467+ init(data: Data) throws {
2468+ self = try newJSONDecoder().decode(TopLevel.MonotheisticallyClass.self, from: data)
2469+ }
2470+
2471+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2472+ guard let data = json.data(using: encoding) else {
2473+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2474+ }
2475+ try self.init(data: data)
2476+ }
2477+
2478+ init(fromURL url: URL) throws {
2479+ try self.init(data: try Data(contentsOf: url))
2480+ }
2481+
2482+ func with(
2483+ blaspheme: JSONNull?? = nil,
2484+ catharticalness: Double?? = nil,
2485+ celiosalpingectomy: JSONNull?? = nil,
2486+ chirotherium: Int?? = nil,
2487+ consummativeness: JSONNull?? = nil,
2488+ disdiapason: String?? = nil,
2489+ egestive: JSONNull?? = nil,
2490+ enchylema: JSONNull?? = nil,
2491+ gasconade: JSONNull?? = nil,
2492+ holidayer: JSONNull?? = nil,
2493+ homocerc: Bool?? = nil,
2494+ intuitionalism: JSONNull?? = nil,
2495+ lophiostomate: JSONNull?? = nil,
2496+ nonbookish: JSONNull?? = nil,
2497+ nonvolition: JSONNull?? = nil,
2498+ palatableness: JSONNull?? = nil,
2499+ pimpery: JSONNull?? = nil,
2500+ previolation: JSONNull?? = nil,
2501+ reconveyance: JSONNull?? = nil,
2502+ registership: JSONNull?? = nil,
2503+ rhyacolite: JSONNull?? = nil,
2504+ smithereens: JSONNull?? = nil,
2505+ superedification: JSONNull?? = nil,
2506+ trust: JSONNull?? = nil,
2507+ whitestone: JSONNull?? = nil
2508+ ) -> TopLevel.MonotheisticallyClass {
2509+ return TopLevel.MonotheisticallyClass(
2510+ blaspheme: blaspheme ?? self.blaspheme,
2511+ catharticalness: catharticalness ?? self.catharticalness,
2512+ celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy,
2513+ chirotherium: chirotherium ?? self.chirotherium,
2514+ consummativeness: consummativeness ?? self.consummativeness,
2515+ disdiapason: disdiapason ?? self.disdiapason,
2516+ egestive: egestive ?? self.egestive,
2517+ enchylema: enchylema ?? self.enchylema,
2518+ gasconade: gasconade ?? self.gasconade,
2519+ holidayer: holidayer ?? self.holidayer,
2520+ homocerc: homocerc ?? self.homocerc,
2521+ intuitionalism: intuitionalism ?? self.intuitionalism,
2522+ lophiostomate: lophiostomate ?? self.lophiostomate,
2523+ nonbookish: nonbookish ?? self.nonbookish,
2524+ nonvolition: nonvolition ?? self.nonvolition,
2525+ palatableness: palatableness ?? self.palatableness,
2526+ pimpery: pimpery ?? self.pimpery,
2527+ previolation: previolation ?? self.previolation,
2528+ reconveyance: reconveyance ?? self.reconveyance,
2529+ registership: registership ?? self.registership,
2530+ rhyacolite: rhyacolite ?? self.rhyacolite,
2531+ smithereens: smithereens ?? self.smithereens,
2532+ superedification: superedification ?? self.superedification,
2533+ trust: trust ?? self.trust,
2534+ whitestone: whitestone ?? self.whitestone
2535+ )
2536+ }
2537+
2538+ func jsonData() throws -> Data {
2539+ return try newJSONEncoder().encode(self)
2540+ }
2541+
2542+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2543+ return String(data: try self.jsonData(), encoding: encoding)
2544+ }
2545+}
2546+
2547+extension TopLevel.Noncontributing {
2548+ init(data: Data) throws {
2549+ self = try newJSONDecoder().decode(TopLevel.Noncontributing.self, from: data)
2550+ }
2551+
2552+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2553+ guard let data = json.data(using: encoding) else {
2554+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2555+ }
2556+ try self.init(data: data)
2557+ }
2558+
2559+ init(fromURL url: URL) throws {
2560+ try self.init(data: try Data(contentsOf: url))
2561+ }
2562+
2563+ func with(
2564+ estevin: String? = nil,
2565+ jolterhead: Double? = nil,
2566+ sauternes: Int? = nil,
2567+ sparsely: Bool? = nil,
2568+ unrequested: JSONNull?? = nil
2569+ ) -> TopLevel.Noncontributing {
2570+ return TopLevel.Noncontributing(
2571+ estevin: estevin ?? self.estevin,
2572+ jolterhead: jolterhead ?? self.jolterhead,
2573+ sauternes: sauternes ?? self.sauternes,
2574+ sparsely: sparsely ?? self.sparsely,
2575+ unrequested: unrequested ?? self.unrequested
2576+ )
2577+ }
2578+
2579+ func jsonData() throws -> Data {
2580+ return try newJSONEncoder().encode(self)
2581+ }
2582+
2583+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2584+ return String(data: try self.jsonData(), encoding: encoding)
2585+ }
2586+}
2587+
2588+extension TopLevel.OccupationalistClass {
2589+ init(data: Data) throws {
2590+ self = try newJSONDecoder().decode(TopLevel.OccupationalistClass.self, from: data)
2591+ }
2592+
2593+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2594+ guard let data = json.data(using: encoding) else {
2595+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2596+ }
2597+ try self.init(data: data)
2598+ }
2599+
2600+ init(fromURL url: URL) throws {
2601+ try self.init(data: try Data(contentsOf: url))
2602+ }
2603+
2604+ func with(
2605+ beholdable: JSONNull?? = nil,
2606+ brotuliform: JSONNull?? = nil,
2607+ chimakum: JSONNull?? = nil,
2608+ doodler: JSONNull?? = nil,
2609+ emulsin: JSONNull?? = nil,
2610+ fin: JSONNull?? = nil,
2611+ flourishing: JSONNull?? = nil,
2612+ flueless: JSONNull?? = nil,
2613+ furtively: JSONNull?? = nil,
2614+ gritter: JSONNull?? = nil,
2615+ interwish: JSONNull?? = nil,
2616+ monoxylic: JSONNull?? = nil,
2617+ myristic: JSONNull?? = nil,
2618+ nightwear: JSONNull?? = nil,
2619+ peruser: JSONNull?? = nil,
2620+ theoastrological: JSONNull?? = nil,
2621+ thumby: JSONNull?? = nil,
2622+ tingitid: JSONNull?? = nil,
2623+ trailless: JSONNull?? = nil,
2624+ unpocketed: JSONNull?? = nil
2625+ ) -> TopLevel.OccupationalistClass {
2626+ return TopLevel.OccupationalistClass(
2627+ beholdable: beholdable ?? self.beholdable,
2628+ brotuliform: brotuliform ?? self.brotuliform,
2629+ chimakum: chimakum ?? self.chimakum,
2630+ doodler: doodler ?? self.doodler,
2631+ emulsin: emulsin ?? self.emulsin,
2632+ fin: fin ?? self.fin,
2633+ flourishing: flourishing ?? self.flourishing,
2634+ flueless: flueless ?? self.flueless,
2635+ furtively: furtively ?? self.furtively,
2636+ gritter: gritter ?? self.gritter,
2637+ interwish: interwish ?? self.interwish,
2638+ monoxylic: monoxylic ?? self.monoxylic,
2639+ myristic: myristic ?? self.myristic,
2640+ nightwear: nightwear ?? self.nightwear,
2641+ peruser: peruser ?? self.peruser,
2642+ theoastrological: theoastrological ?? self.theoastrological,
2643+ thumby: thumby ?? self.thumby,
2644+ tingitid: tingitid ?? self.tingitid,
2645+ trailless: trailless ?? self.trailless,
2646+ unpocketed: unpocketed ?? self.unpocketed
2647+ )
2648+ }
2649+
2650+ func jsonData() throws -> Data {
2651+ return try newJSONEncoder().encode(self)
2652+ }
2653+
2654+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2655+ return String(data: try self.jsonData(), encoding: encoding)
2656+ }
2657+}
2658+
2659+extension TopLevel.OutrivalClass {
2660+ init(data: Data) throws {
2661+ self = try newJSONDecoder().decode(TopLevel.OutrivalClass.self, from: data)
2662+ }
2663+
2664+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2665+ guard let data = json.data(using: encoding) else {
2666+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2667+ }
2668+ try self.init(data: data)
2669+ }
2670+
2671+ init(fromURL url: URL) throws {
2672+ try self.init(data: try Data(contentsOf: url))
2673+ }
2674+
2675+ func with(
2676+ adroitly: JSONNull?? = nil,
2677+ bridehood: JSONNull?? = nil,
2678+ castoroides: JSONNull?? = nil,
2679+ czechoslovak: JSONNull?? = nil,
2680+ diagenesis: JSONNull?? = nil,
2681+ dihexahedron: JSONNull?? = nil,
2682+ dopester: JSONNull?? = nil,
2683+ eumerism: JSONNull?? = nil,
2684+ flyness: JSONNull?? = nil,
2685+ fouler: JSONNull?? = nil,
2686+ laudanosine: JSONNull?? = nil,
2687+ lingulidae: JSONNull?? = nil,
2688+ minutary: JSONNull?? = nil,
2689+ mitra: JSONNull?? = nil,
2690+ opisthorchiasis: JSONNull?? = nil,
2691+ pensively: JSONNull?? = nil,
2692+ pubigerous: JSONNull?? = nil,
2693+ rebellious: JSONNull?? = nil,
2694+ recodify: JSONNull?? = nil,
2695+ unpaced: JSONNull?? = nil
2696+ ) -> TopLevel.OutrivalClass {
2697+ return TopLevel.OutrivalClass(
2698+ adroitly: adroitly ?? self.adroitly,
2699+ bridehood: bridehood ?? self.bridehood,
2700+ castoroides: castoroides ?? self.castoroides,
2701+ czechoslovak: czechoslovak ?? self.czechoslovak,
2702+ diagenesis: diagenesis ?? self.diagenesis,
2703+ dihexahedron: dihexahedron ?? self.dihexahedron,
2704+ dopester: dopester ?? self.dopester,
2705+ eumerism: eumerism ?? self.eumerism,
2706+ flyness: flyness ?? self.flyness,
2707+ fouler: fouler ?? self.fouler,
2708+ laudanosine: laudanosine ?? self.laudanosine,
2709+ lingulidae: lingulidae ?? self.lingulidae,
2710+ minutary: minutary ?? self.minutary,
2711+ mitra: mitra ?? self.mitra,
2712+ opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis,
2713+ pensively: pensively ?? self.pensively,
2714+ pubigerous: pubigerous ?? self.pubigerous,
2715+ rebellious: rebellious ?? self.rebellious,
2716+ recodify: recodify ?? self.recodify,
2717+ unpaced: unpaced ?? self.unpaced
2718+ )
2719+ }
2720+
2721+ func jsonData() throws -> Data {
2722+ return try newJSONEncoder().encode(self)
2723+ }
2724+
2725+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2726+ return String(data: try self.jsonData(), encoding: encoding)
2727+ }
2728+}
2729+
2730+extension TopLevel.PiaculumClass {
2731+ init(data: Data) throws {
2732+ self = try newJSONDecoder().decode(TopLevel.PiaculumClass.self, from: data)
2733+ }
2734+
2735+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2736+ guard let data = json.data(using: encoding) else {
2737+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2738+ }
2739+ try self.init(data: data)
2740+ }
2741+
2742+ init(fromURL url: URL) throws {
2743+ try self.init(data: try Data(contentsOf: url))
2744+ }
2745+
2746+ func with(
2747+ alada: Int?? = nil,
2748+ amphistomous: Int?? = nil,
2749+ boysenberry: Int?? = nil,
2750+ catharticalness: Double?? = nil,
2751+ chirotherium: Int?? = nil,
2752+ decardinalize: Int?? = nil,
2753+ discouragement: Int?? = nil,
2754+ disdiapason: String?? = nil,
2755+ doitrified: Int?? = nil,
2756+ hexaspermous: Int?? = nil,
2757+ homocerc: Bool?? = nil,
2758+ insinking: Int?? = nil,
2759+ loathfulness: Int?? = nil,
2760+ miasmatical: Int?? = nil,
2761+ neurofibril: Int?? = nil,
2762+ nonbookish: JSONNull?? = nil,
2763+ phonendoscope: Int?? = nil,
2764+ pilferment: Int?? = nil,
2765+ predismissory: Int?? = nil,
2766+ preinscription: Int?? = nil,
2767+ quotative: Int?? = nil,
2768+ sienna: Int?? = nil,
2769+ thorax: Int?? = nil,
2770+ yachting: Int?? = nil,
2771+ zipper: Int?? = nil
2772+ ) -> TopLevel.PiaculumClass {
2773+ return TopLevel.PiaculumClass(
2774+ alada: alada ?? self.alada,
2775+ amphistomous: amphistomous ?? self.amphistomous,
2776+ boysenberry: boysenberry ?? self.boysenberry,
2777+ catharticalness: catharticalness ?? self.catharticalness,
2778+ chirotherium: chirotherium ?? self.chirotherium,
2779+ decardinalize: decardinalize ?? self.decardinalize,
2780+ discouragement: discouragement ?? self.discouragement,
2781+ disdiapason: disdiapason ?? self.disdiapason,
2782+ doitrified: doitrified ?? self.doitrified,
2783+ hexaspermous: hexaspermous ?? self.hexaspermous,
2784+ homocerc: homocerc ?? self.homocerc,
2785+ insinking: insinking ?? self.insinking,
2786+ loathfulness: loathfulness ?? self.loathfulness,
2787+ miasmatical: miasmatical ?? self.miasmatical,
2788+ neurofibril: neurofibril ?? self.neurofibril,
2789+ nonbookish: nonbookish ?? self.nonbookish,
2790+ phonendoscope: phonendoscope ?? self.phonendoscope,
2791+ pilferment: pilferment ?? self.pilferment,
2792+ predismissory: predismissory ?? self.predismissory,
2793+ preinscription: preinscription ?? self.preinscription,
2794+ quotative: quotative ?? self.quotative,
2795+ sienna: sienna ?? self.sienna,
2796+ thorax: thorax ?? self.thorax,
2797+ yachting: yachting ?? self.yachting,
2798+ zipper: zipper ?? self.zipper
2799+ )
2800+ }
2801+
2802+ func jsonData() throws -> Data {
2803+ return try newJSONEncoder().encode(self)
2804+ }
2805+
2806+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2807+ return String(data: try self.jsonData(), encoding: encoding)
2808+ }
2809+}
2810+
2811+extension TopLevel.Pneumocele {
2812+ init(data: Data) throws {
2813+ self = try newJSONDecoder().decode(TopLevel.Pneumocele.self, from: data)
2814+ }
2815+
2816+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2817+ guard let data = json.data(using: encoding) else {
2818+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2819+ }
2820+ try self.init(data: data)
2821+ }
2822+
2823+ init(fromURL url: URL) throws {
2824+ try self.init(data: try Data(contentsOf: url))
2825+ }
2826+
2827+ func with(
2828+ carbonarism: JSONNull?? = nil,
2829+ catharticalness: Double?? = nil,
2830+ chirotherium: Int?? = nil,
2831+ cineolic: JSONNull?? = nil,
2832+ cobbly: JSONNull?? = nil,
2833+ conchyliferous: JSONNull?? = nil,
2834+ congregation: JSONNull?? = nil,
2835+ disdiapason: String?? = nil,
2836+ enterotomy: JSONNull?? = nil,
2837+ entophytal: JSONNull?? = nil,
2838+ fewtrils: JSONNull?? = nil,
2839+ herem: JSONNull?? = nil,
2840+ homocerc: Bool?? = nil,
2841+ koniga: JSONNull?? = nil,
2842+ meticulosity: JSONNull?? = nil,
2843+ micky: JSONNull?? = nil,
2844+ mismarriage: JSONNull?? = nil,
2845+ neurotrophic: JSONNull?? = nil,
2846+ nonbookish: JSONNull?? = nil,
2847+ persuasively: JSONNull?? = nil,
2848+ replaceable: JSONNull?? = nil,
2849+ silex: JSONNull?? = nil,
2850+ taillight: JSONNull?? = nil,
2851+ unjealous: JSONNull?? = nil,
2852+ visitorial: JSONNull?? = nil
2853+ ) -> TopLevel.Pneumocele {
2854+ return TopLevel.Pneumocele(
2855+ carbonarism: carbonarism ?? self.carbonarism,
2856+ catharticalness: catharticalness ?? self.catharticalness,
2857+ chirotherium: chirotherium ?? self.chirotherium,
2858+ cineolic: cineolic ?? self.cineolic,
2859+ cobbly: cobbly ?? self.cobbly,
2860+ conchyliferous: conchyliferous ?? self.conchyliferous,
2861+ congregation: congregation ?? self.congregation,
2862+ disdiapason: disdiapason ?? self.disdiapason,
2863+ enterotomy: enterotomy ?? self.enterotomy,
2864+ entophytal: entophytal ?? self.entophytal,
2865+ fewtrils: fewtrils ?? self.fewtrils,
2866+ herem: herem ?? self.herem,
2867+ homocerc: homocerc ?? self.homocerc,
2868+ koniga: koniga ?? self.koniga,
2869+ meticulosity: meticulosity ?? self.meticulosity,
2870+ micky: micky ?? self.micky,
2871+ mismarriage: mismarriage ?? self.mismarriage,
2872+ neurotrophic: neurotrophic ?? self.neurotrophic,
2873+ nonbookish: nonbookish ?? self.nonbookish,
2874+ persuasively: persuasively ?? self.persuasively,
2875+ replaceable: replaceable ?? self.replaceable,
2876+ silex: silex ?? self.silex,
2877+ taillight: taillight ?? self.taillight,
2878+ unjealous: unjealous ?? self.unjealous,
2879+ visitorial: visitorial ?? self.visitorial
2880+ )
2881+ }
2882+
2883+ func jsonData() throws -> Data {
2884+ return try newJSONEncoder().encode(self)
2885+ }
2886+
2887+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2888+ return String(data: try self.jsonData(), encoding: encoding)
2889+ }
2890+}
2891+
2892+extension TopLevel.PotwhiskyClass {
2893+ init(data: Data) throws {
2894+ self = try newJSONDecoder().decode(TopLevel.PotwhiskyClass.self, from: data)
2895+ }
2896+
2897+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2898+ guard let data = json.data(using: encoding) else {
2899+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2900+ }
2901+ try self.init(data: data)
2902+ }
2903+
2904+ init(fromURL url: URL) throws {
2905+ try self.init(data: try Data(contentsOf: url))
2906+ }
2907+
2908+ func with(
2909+ arciform: JSONNull?? = nil,
2910+ cresolin: JSONNull?? = nil,
2911+ disheartener: JSONNull?? = nil,
2912+ disproportionable: JSONNull?? = nil,
2913+ euchorda: JSONNull?? = nil,
2914+ ferryway: JSONNull?? = nil,
2915+ filamentiferous: JSONNull?? = nil,
2916+ flemish: JSONNull?? = nil,
2917+ forgainst: JSONNull?? = nil,
2918+ grainering: JSONNull?? = nil,
2919+ irrevoluble: JSONNull?? = nil,
2920+ kindredship: JSONNull?? = nil,
2921+ pinguitudinous: JSONNull?? = nil,
2922+ simpletonic: JSONNull?? = nil,
2923+ singsong: JSONNull?? = nil,
2924+ submergement: JSONNull?? = nil,
2925+ supraoesophagal: JSONNull?? = nil,
2926+ thrashel: JSONNull?? = nil,
2927+ tyremesis: JSONNull?? = nil,
2928+ yoruba: JSONNull?? = nil
2929+ ) -> TopLevel.PotwhiskyClass {
2930+ return TopLevel.PotwhiskyClass(
2931+ arciform: arciform ?? self.arciform,
2932+ cresolin: cresolin ?? self.cresolin,
2933+ disheartener: disheartener ?? self.disheartener,
2934+ disproportionable: disproportionable ?? self.disproportionable,
2935+ euchorda: euchorda ?? self.euchorda,
2936+ ferryway: ferryway ?? self.ferryway,
2937+ filamentiferous: filamentiferous ?? self.filamentiferous,
2938+ flemish: flemish ?? self.flemish,
2939+ forgainst: forgainst ?? self.forgainst,
2940+ grainering: grainering ?? self.grainering,
2941+ irrevoluble: irrevoluble ?? self.irrevoluble,
2942+ kindredship: kindredship ?? self.kindredship,
2943+ pinguitudinous: pinguitudinous ?? self.pinguitudinous,
2944+ simpletonic: simpletonic ?? self.simpletonic,
2945+ singsong: singsong ?? self.singsong,
2946+ submergement: submergement ?? self.submergement,
2947+ supraoesophagal: supraoesophagal ?? self.supraoesophagal,
2948+ thrashel: thrashel ?? self.thrashel,
2949+ tyremesis: tyremesis ?? self.tyremesis,
2950+ yoruba: yoruba ?? self.yoruba
2951+ )
2952+ }
2953+
2954+ func jsonData() throws -> Data {
2955+ return try newJSONEncoder().encode(self)
2956+ }
2957+
2958+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2959+ return String(data: try self.jsonData(), encoding: encoding)
2960+ }
2961+}
2962+
2963+extension TopLevel.PrefreshmanClass {
2964+ init(data: Data) throws {
2965+ self = try newJSONDecoder().decode(TopLevel.PrefreshmanClass.self, from: data)
2966+ }
2967+
2968+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2969+ guard let data = json.data(using: encoding) else {
2970+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2971+ }
2972+ try self.init(data: data)
2973+ }
2974+
2975+ init(fromURL url: URL) throws {
2976+ try self.init(data: try Data(contentsOf: url))
2977+ }
2978+
2979+ func with(
2980+ azorubine: JSONNull?? = nil,
2981+ choroiditis: JSONNull?? = nil,
2982+ coagulatory: JSONNull?? = nil,
2983+ cyclorama: JSONNull?? = nil,
2984+ dolphus: JSONNull?? = nil,
2985+ duckhearted: JSONNull?? = nil,
2986+ ficus: JSONNull?? = nil,
2987+ gemaric: JSONNull?? = nil,
2988+ jugation: JSONNull?? = nil,
2989+ myoliposis: JSONNull?? = nil,
2990+ nonnomination: JSONNull?? = nil,
2991+ palay: JSONNull?? = nil,
2992+ pentactinal: JSONNull?? = nil,
2993+ phaet: JSONNull?? = nil,
2994+ piquant: JSONNull?? = nil,
2995+ registration: JSONNull?? = nil,
2996+ remancipation: JSONNull?? = nil,
2997+ scutatiform: JSONNull?? = nil,
2998+ theodolite: JSONNull?? = nil,
2999+ underward: JSONNull?? = nil
3000+ ) -> TopLevel.PrefreshmanClass {
3001+ return TopLevel.PrefreshmanClass(
3002+ azorubine: azorubine ?? self.azorubine,
3003+ choroiditis: choroiditis ?? self.choroiditis,
3004+ coagulatory: coagulatory ?? self.coagulatory,
3005+ cyclorama: cyclorama ?? self.cyclorama,
3006+ dolphus: dolphus ?? self.dolphus,
3007+ duckhearted: duckhearted ?? self.duckhearted,
3008+ ficus: ficus ?? self.ficus,
3009+ gemaric: gemaric ?? self.gemaric,
3010+ jugation: jugation ?? self.jugation,
3011+ myoliposis: myoliposis ?? self.myoliposis,
3012+ nonnomination: nonnomination ?? self.nonnomination,
3013+ palay: palay ?? self.palay,
3014+ pentactinal: pentactinal ?? self.pentactinal,
3015+ phaet: phaet ?? self.phaet,
3016+ piquant: piquant ?? self.piquant,
3017+ registration: registration ?? self.registration,
3018+ remancipation: remancipation ?? self.remancipation,
3019+ scutatiform: scutatiform ?? self.scutatiform,
3020+ theodolite: theodolite ?? self.theodolite,
3021+ underward: underward ?? self.underward
3022+ )
3023+ }
3024+
3025+ func jsonData() throws -> Data {
3026+ return try newJSONEncoder().encode(self)
3027+ }
3028+
3029+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3030+ return String(data: try self.jsonData(), encoding: encoding)
3031+ }
3032+}
3033+
3034+// MARK: - Helper functions for creating encoders and decoders
3035+
3036+func newJSONDecoder() -> JSONDecoder {
3037+ let decoder = JSONDecoder()
3038+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
3039+ let container = try decoder.singleValueContainer()
3040+ let dateStr = try container.decode(String.self)
3041+
3042+ let formatter = DateFormatter()
3043+ formatter.calendar = Calendar(identifier: .iso8601)
3044+ formatter.locale = Locale(identifier: "en_US_POSIX")
3045+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3046+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
3047+ if let date = formatter.date(from: dateStr) {
3048+ return date
3049+ }
3050+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3051+ if let date = formatter.date(from: dateStr) {
3052+ return date
3053+ }
3054+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
3055+ })
3056+ return decoder
3057+}
3058+
3059+func newJSONEncoder() -> JSONEncoder {
3060+ let encoder = JSONEncoder()
3061+ let formatter = DateFormatter()
3062+ formatter.calendar = Calendar(identifier: .iso8601)
3063+ formatter.locale = Locale(identifier: "en_US_POSIX")
3064+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3065+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3066+ encoder.dateEncodingStrategy = .formatted(formatter)
3067+ return encoder
3068+}
3069+
3070+// MARK: - Encode/decode helpers
3071+
3072+class JSONNull: Codable, Hashable {
3073+
3074+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3075+ return true
3076+ }
3077+
3078+ public func hash(into hasher: inout Hasher) {
3079+ hasher.combine(0)
3080+ }
3081+
3082+ public init() {}
3083+
3084+ public required init(from decoder: Decoder) throws {
3085+ let container = try decoder.singleValueContainer()
3086+ if !container.decodeNil() {
3087+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3088+ }
3089+ }
3090+
3091+ public func encode(to encoder: Encoder) throws {
3092+ var container = encoder.singleValueContainer()
3093+ try container.encodeNil()
3094+ }
3095+}
Test case

test/inputs/json/priority/combinations4.json

1 generated file · +3,593 −0
Aswiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+3,593 −0
@@ -0,0 +1,3593 @@
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+struct TopLevel: Codable {
10+ let protrusive: [TopLevel.Protrusive]
11+ let pulpitism: [TopLevel.PulpitismElement]
12+ let pyodermia: [TopLevel.PyodermiaElement]
13+ let quebrachine: [TopLevel.QuebrachineElement]
14+ let querier: [TopLevel.Querier]
15+ let rebarbative: [TopLevel.Rebarbative]
16+ let reimagine: [TopLevel.Reimagine]
17+ let ressaut: TopLevel.Ressaut
18+ let retrocervical: [TopLevel.Retrocervical]
19+ let revert: [TopLevel.Revert]
20+ let rewrite: [TopLevel.RewriteElement]
21+ let saccoderm: [TopLevel.Saccoderm]
22+ let santir: [TopLevel.SantirElement]
23+ let saprophilous: [TopLevel.Saprophilous]
24+ let saxten: [TopLevel.SaxtenElement]
25+ let scatty: [TopLevel.Scatty?]
26+ let scoffer: [TopLevel.Scoffer]
27+ let scrampum: [TopLevel.Scrampum]
28+ let semantic: Double
29+ let serpentinic: [TopLevel.Serpentinic]
30+ let shadowable: [TopLevel.Shadowable]
31+ let sistering: [TopLevel.SisteringElement]
32+ let staghunting: [TopLevel.Staghunting]
33+ let stagmometer: [TopLevel.Stagmometer]
34+ let stimulability: [TopLevel.Stimulability]
35+ let strangleable: [TopLevel.Strangleable]
36+ let strenuosity: [TopLevel.StrenuosityElement]
37+ let tabaxir: [TopLevel.Tabaxir]
38+ let talpiform: [TopLevel.Talpiform]
39+ let thwack: [TopLevel.Thwack]
40+ let to: [Double?]
41+ let tortricine: [TopLevel.Tortricine]
42+ let truantcy: [TopLevel.TruantcyElement]
43+ let turgesce: [String]
44+ let unbeginning: [TopLevel.Unbeginning]
45+ let underdunged: [Double]
46+ let undesirability: [TopLevel.Undesirability]
47+ let unerasing: [TopLevel.Unerasing]
48+ let unguentarium: [TopLevel.Unguentarium]
49+ let unimpeachably: [TopLevel.UnimpeachablyElement]
50+ let unmortgaged: [TopLevel.Unmortgaged]
51+ let unobstructed: [TopLevel.Unobstructed]
52+ let unreceptivity: [TopLevel.Unreceptivity]
53+ let unsatisfactoriness: [TopLevel.Unsatisfactoriness]
54+ let unsecurity: [Int]
55+ let unstressed: [TopLevel.UnstressedElement]
56+ let untasked: [TopLevel.Untasked]
57+ let unvarying: [TopLevel.Unvarying]
58+ let vehemently: [TopLevel.Vehemently]
59+ let warriorship: [String: Bool]
60+ let whitepot: [TopLevel.Whitepot]
61+ let wrothy: [TopLevel.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+ enum Protrusive: Codable {
119+ case double(Double)
120+ case unionArray([Int?])
121+
122+ init(from decoder: Decoder) throws {
123+ let container = try decoder.singleValueContainer()
124+ if let x = try? container.decode([Int?].self) {
125+ self = .unionArray(x)
126+ return
127+ }
128+ if let x = try? container.decode(Double.self) {
129+ self = .double(x)
130+ return
131+ }
132+ throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive"))
133+ }
134+
135+ func encode(to encoder: Encoder) throws {
136+ var container = encoder.singleValueContainer()
137+ switch self {
138+ case .double(let x):
139+ try container.encode(x)
140+ case .unionArray(let x):
141+ try container.encode(x)
142+ }
143+ }
144+ }
145+
146+ enum PulpitismElement: Codable {
147+ case double(Double)
148+ case integerArray([Int])
149+ case pulpitismClass(TopLevel.PulpitismClass)
150+
151+ init(from decoder: Decoder) throws {
152+ let container = try decoder.singleValueContainer()
153+ if let x = try? container.decode([Int].self) {
154+ self = .integerArray(x)
155+ return
156+ }
157+ if let x = try? container.decode(Double.self) {
158+ self = .double(x)
159+ return
160+ }
161+ if let x = try? container.decode(TopLevel.PulpitismClass.self) {
162+ self = .pulpitismClass(x)
163+ return
164+ }
165+ throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement"))
166+ }
167+
168+ func encode(to encoder: Encoder) throws {
169+ var container = encoder.singleValueContainer()
170+ switch self {
171+ case .double(let x):
172+ try container.encode(x)
173+ case .integerArray(let x):
174+ try container.encode(x)
175+ case .pulpitismClass(let x):
176+ try container.encode(x)
177+ }
178+ }
179+ }
180+
181+ struct PulpitismClass: Codable {
182+ let abnet: JSONNull?
183+ let buckhorn: JSONNull?
184+ let calciform: JSONNull?
185+ let chelophore: JSONNull?
186+ let cogitation: JSONNull?
187+ let decreeable: JSONNull?
188+ let despicable: JSONNull?
189+ let isodiazo: JSONNull?
190+ let jadedly: JSONNull?
191+ let leptochlorite: JSONNull?
192+ let nursling: JSONNull?
193+ let palamedean: JSONNull?
194+ let photoheliograph: JSONNull?
195+ let pipewood: JSONNull?
196+ let roberd: JSONNull?
197+ let statable: JSONNull?
198+ let superassume: JSONNull?
199+ let syllabe: JSONNull?
200+ let toughhead: JSONNull?
201+ let underburn: JSONNull?
202+
203+ enum CodingKeys: String, CodingKey {
204+ case abnet = "abnet"
205+ case buckhorn = "buckhorn"
206+ case calciform = "calciform"
207+ case chelophore = "chelophore"
208+ case cogitation = "cogitation"
209+ case decreeable = "decreeable"
210+ case despicable = "despicable"
211+ case isodiazo = "isodiazo"
212+ case jadedly = "jadedly"
213+ case leptochlorite = "leptochlorite"
214+ case nursling = "nursling"
215+ case palamedean = "palamedean"
216+ case photoheliograph = "photoheliograph"
217+ case pipewood = "pipewood"
218+ case roberd = "roberd"
219+ case statable = "statable"
220+ case superassume = "superassume"
221+ case syllabe = "syllabe"
222+ case toughhead = "toughhead"
223+ case underburn = "underburn"
224+ }
225+ }
226+
227+ enum PyodermiaElement: Codable {
228+ case integer(Int)
229+ case pyodermiaClass(TopLevel.PyodermiaClass)
230+
231+ init(from decoder: Decoder) throws {
232+ let container = try decoder.singleValueContainer()
233+ if let x = try? container.decode(Int.self) {
234+ self = .integer(x)
235+ return
236+ }
237+ if let x = try? container.decode(TopLevel.PyodermiaClass.self) {
238+ self = .pyodermiaClass(x)
239+ return
240+ }
241+ throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement"))
242+ }
243+
244+ func encode(to encoder: Encoder) throws {
245+ var container = encoder.singleValueContainer()
246+ switch self {
247+ case .integer(let x):
248+ try container.encode(x)
249+ case .pyodermiaClass(let x):
250+ try container.encode(x)
251+ }
252+ }
253+ }
254+
255+ struct PyodermiaClass: Codable {
256+ let aphoristically: JSONNull?
257+ let apophyllous: JSONNull?
258+ let cognize: JSONNull?
259+ let dermonosology: JSONNull?
260+ let gyppo: JSONNull?
261+ let ither: JSONNull?
262+ let juglandaceous: JSONNull?
263+ let litho: JSONNull?
264+ let macropterous: JSONNull?
265+ let photographer: JSONNull?
266+ let romancing: JSONNull?
267+ let rumness: JSONNull?
268+ let somniloquist: JSONNull?
269+ let stressfully: JSONNull?
270+ let tactically: JSONNull?
271+ let tracheophony: JSONNull?
272+ let unappositely: JSONNull?
273+ let unclothedly: JSONNull?
274+ let unimplied: JSONNull?
275+ let unsyncopated: JSONNull?
276+
277+ enum CodingKeys: String, CodingKey {
278+ case aphoristically = "aphoristically"
279+ case apophyllous = "apophyllous"
280+ case cognize = "cognize"
281+ case dermonosology = "dermonosology"
282+ case gyppo = "Gyppo"
283+ case ither = "ither"
284+ case juglandaceous = "juglandaceous"
285+ case litho = "litho"
286+ case macropterous = "macropterous"
287+ case photographer = "photographer"
288+ case romancing = "romancing"
289+ case rumness = "rumness"
290+ case somniloquist = "somniloquist"
291+ case stressfully = "stressfully"
292+ case tactically = "tactically"
293+ case tracheophony = "tracheophony"
294+ case unappositely = "unappositely"
295+ case unclothedly = "unclothedly"
296+ case unimplied = "unimplied"
297+ case unsyncopated = "unsyncopated"
298+ }
299+ }
300+
301+ enum QuebrachineElement: Codable {
302+ case bool(Bool)
303+ case quebrachineClass(TopLevel.QuebrachineClass)
304+ case null
305+
306+ init(from decoder: Decoder) throws {
307+ let container = try decoder.singleValueContainer()
308+ if let x = try? container.decode(Bool.self) {
309+ self = .bool(x)
310+ return
311+ }
312+ if let x = try? container.decode(TopLevel.QuebrachineClass.self) {
313+ self = .quebrachineClass(x)
314+ return
315+ }
316+ if container.decodeNil() {
317+ self = .null
318+ return
319+ }
320+ throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement"))
321+ }
322+
323+ func encode(to encoder: Encoder) throws {
324+ var container = encoder.singleValueContainer()
325+ switch self {
326+ case .bool(let x):
327+ try container.encode(x)
328+ case .quebrachineClass(let x):
329+ try container.encode(x)
330+ case .null:
331+ try container.encodeNil()
332+ }
333+ }
334+ }
335+
336+ struct QuebrachineClass: Codable {
337+ let catharticalness: Double
338+ let chirotherium: Int
339+ let disdiapason: String
340+ let homocerc: Bool
341+ let nonbookish: JSONNull?
342+
343+ enum CodingKeys: String, CodingKey {
344+ case catharticalness = "catharticalness"
345+ case chirotherium = "Chirotherium"
346+ case disdiapason = "disdiapason"
347+ case homocerc = "homocerc"
348+ case nonbookish = "nonbookish"
349+ }
350+ }
351+
352+ enum Querier: Codable {
353+ case bool(Bool)
354+ case integerMap([String: Int])
355+
356+ init(from decoder: Decoder) throws {
357+ let container = try decoder.singleValueContainer()
358+ if let x = try? container.decode(Bool.self) {
359+ self = .bool(x)
360+ return
361+ }
362+ if let x = try? container.decode([String: Int].self) {
363+ self = .integerMap(x)
364+ return
365+ }
366+ throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier"))
367+ }
368+
369+ func encode(to encoder: Encoder) throws {
370+ var container = encoder.singleValueContainer()
371+ switch self {
372+ case .bool(let x):
373+ try container.encode(x)
374+ case .integerMap(let x):
375+ try container.encode(x)
376+ }
377+ }
378+ }
379+
380+ enum Rebarbative: Codable {
381+ case bool(Bool)
382+ case double(Double)
383+ case integerArray([Int])
384+
385+ init(from decoder: Decoder) throws {
386+ let container = try decoder.singleValueContainer()
387+ if let x = try? container.decode(Bool.self) {
388+ self = .bool(x)
389+ return
390+ }
391+ if let x = try? container.decode([Int].self) {
392+ self = .integerArray(x)
393+ return
394+ }
395+ if let x = try? container.decode(Double.self) {
396+ self = .double(x)
397+ return
398+ }
399+ throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative"))
400+ }
401+
402+ func encode(to encoder: Encoder) throws {
403+ var container = encoder.singleValueContainer()
404+ switch self {
405+ case .bool(let x):
406+ try container.encode(x)
407+ case .double(let x):
408+ try container.encode(x)
409+ case .integerArray(let x):
410+ try container.encode(x)
411+ }
412+ }
413+ }
414+
415+ struct Reimagine: Codable {
416+ let adducible: JSONNull?
417+ let anabolin: JSONNull?
418+ let brainy: JSONNull?
419+ let catharticalness: Double?
420+ let chirotherium: Int?
421+ let chrysamine: JSONNull?
422+ let disdiapason: String?
423+ let fluxweed: JSONNull?
424+ let glaucine: JSONNull?
425+ let grobianism: JSONNull?
426+ let hermo: JSONNull?
427+ let hieroglyphist: JSONNull?
428+ let homocerc: Bool?
429+ let icteroid: JSONNull?
430+ let immortal: JSONNull?
431+ let impetulant: JSONNull?
432+ let irrigate: JSONNull?
433+ let myxedema: JSONNull?
434+ let nonbookish: JSONNull?
435+ let onyx: JSONNull?
436+ let repasser: JSONNull?
437+ let septomarginal: JSONNull?
438+ let subdie: JSONNull?
439+ let tibiometatarsal: JSONNull?
440+ let waltzlike: JSONNull?
441+
442+ enum CodingKeys: String, CodingKey {
443+ case adducible = "adducible"
444+ case anabolin = "anabolin"
445+ case brainy = "brainy"
446+ case catharticalness = "catharticalness"
447+ case chirotherium = "Chirotherium"
448+ case chrysamine = "chrysamine"
449+ case disdiapason = "disdiapason"
450+ case fluxweed = "fluxweed"
451+ case glaucine = "glaucine"
452+ case grobianism = "grobianism"
453+ case hermo = "Hermo"
454+ case hieroglyphist = "hieroglyphist"
455+ case homocerc = "homocerc"
456+ case icteroid = "icteroid"
457+ case immortal = "immortal"
458+ case impetulant = "impetulant"
459+ case irrigate = "irrigate"
460+ case myxedema = "myxedema"
461+ case nonbookish = "nonbookish"
462+ case onyx = "onyx"
463+ case repasser = "repasser"
464+ case septomarginal = "septomarginal"
465+ case subdie = "subdie"
466+ case tibiometatarsal = "tibiometatarsal"
467+ case waltzlike = "waltzlike"
468+ }
469+ }
470+
471+ struct Ressaut: Codable {
472+ let apperceptive: String
473+ let cuttoo: String
474+ let douser: String
475+ let drinkproof: String
476+ let forementioned: String
477+ let freesia: String
478+ let genevieve: String
479+ let hyperdiabolical: String
480+ let hypocone: String
481+ let irreverentially: String
482+ let jumart: String
483+ let mimosaceae: String
484+ let mollicrush: String
485+ let nedder: String
486+ let retinasphalt: String
487+ let sough: String
488+ let steading: String
489+ let theopaschitism: String
490+ let undurableness: String
491+ let unmingleable: String
492+
493+ enum CodingKeys: String, CodingKey {
494+ case apperceptive = "apperceptive"
495+ case cuttoo = "cuttoo"
496+ case douser = "douser"
497+ case drinkproof = "drinkproof"
498+ case forementioned = "forementioned"
499+ case freesia = "Freesia"
500+ case genevieve = "Genevieve"
501+ case hyperdiabolical = "hyperdiabolical"
502+ case hypocone = "hypocone"
503+ case irreverentially = "irreverentially"
504+ case jumart = "jumart"
505+ case mimosaceae = "Mimosaceae"
506+ case mollicrush = "mollicrush"
507+ case nedder = "nedder"
508+ case retinasphalt = "retinasphalt"
509+ case sough = "sough"
510+ case steading = "steading"
511+ case theopaschitism = "Theopaschitism"
512+ case undurableness = "undurableness"
513+ case unmingleable = "unmingleable"
514+ }
515+ }
516+
517+ enum Retrocervical: Codable {
518+ case integer(Int)
519+ case unionArray([Int?])
520+
521+ init(from decoder: Decoder) throws {
522+ let container = try decoder.singleValueContainer()
523+ if let x = try? container.decode(Int.self) {
524+ self = .integer(x)
525+ return
526+ }
527+ if let x = try? container.decode([Int?].self) {
528+ self = .unionArray(x)
529+ return
530+ }
531+ throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical"))
532+ }
533+
534+ func encode(to encoder: Encoder) throws {
535+ var container = encoder.singleValueContainer()
536+ switch self {
537+ case .integer(let x):
538+ try container.encode(x)
539+ case .unionArray(let x):
540+ try container.encode(x)
541+ }
542+ }
543+ }
544+
545+ enum Revert: Codable {
546+ case bool(Bool)
547+ case string(String)
548+
549+ init(from decoder: Decoder) throws {
550+ let container = try decoder.singleValueContainer()
551+ if let x = try? container.decode(Bool.self) {
552+ self = .bool(x)
553+ return
554+ }
555+ if let x = try? container.decode(String.self) {
556+ self = .string(x)
557+ return
558+ }
559+ throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert"))
560+ }
561+
562+ func encode(to encoder: Encoder) throws {
563+ var container = encoder.singleValueContainer()
564+ switch self {
565+ case .bool(let x):
566+ try container.encode(x)
567+ case .string(let x):
568+ try container.encode(x)
569+ }
570+ }
571+ }
572+
573+ enum RewriteElement: Codable {
574+ case double(Double)
575+ case nullArray([JSONNull?])
576+ case rewriteClass(TopLevel.RewriteClass)
577+
578+ init(from decoder: Decoder) throws {
579+ let container = try decoder.singleValueContainer()
580+ if let x = try? container.decode([JSONNull?].self) {
581+ self = .nullArray(x)
582+ return
583+ }
584+ if let x = try? container.decode(Double.self) {
585+ self = .double(x)
586+ return
587+ }
588+ if let x = try? container.decode(TopLevel.RewriteClass.self) {
589+ self = .rewriteClass(x)
590+ return
591+ }
592+ throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement"))
593+ }
594+
595+ func encode(to encoder: Encoder) throws {
596+ var container = encoder.singleValueContainer()
597+ switch self {
598+ case .double(let x):
599+ try container.encode(x)
600+ case .nullArray(let x):
601+ try container.encode(x)
602+ case .rewriteClass(let x):
603+ try container.encode(x)
604+ }
605+ }
606+ }
607+
608+ struct RewriteClass: Codable {
609+ let accountancy: JSONNull?
610+ let cacotrophic: JSONNull?
611+ let contest: JSONNull?
612+ let couthily: JSONNull?
613+ let falculate: JSONNull?
614+ let foreseize: JSONNull?
615+ let hyades: JSONNull?
616+ let lemnad: JSONNull?
617+ let monotheistically: JSONNull?
618+ let nonflying: JSONNull?
619+ let ptenoglossa: JSONNull?
620+ let repatch: JSONNull?
621+ let rodman: JSONNull?
622+ let strung: JSONNull?
623+ let titmal: JSONNull?
624+ let twalpennyworth: JSONNull?
625+ let unblamable: JSONNull?
626+ let vertical: JSONNull?
627+ let whiggification: JSONNull?
628+ let yardman: JSONNull?
629+
630+ enum CodingKeys: String, CodingKey {
631+ case accountancy = "accountancy"
632+ case cacotrophic = "cacotrophic"
633+ case contest = "contest"
634+ case couthily = "couthily"
635+ case falculate = "falculate"
636+ case foreseize = "foreseize"
637+ case hyades = "Hyades"
638+ case lemnad = "lemnad"
639+ case monotheistically = "monotheistically"
640+ case nonflying = "nonflying"
641+ case ptenoglossa = "Ptenoglossa"
642+ case repatch = "repatch"
643+ case rodman = "rodman"
644+ case strung = "strung"
645+ case titmal = "titmal"
646+ case twalpennyworth = "twalpennyworth"
647+ case unblamable = "unblamable"
648+ case vertical = "vertical"
649+ case whiggification = "Whiggification"
650+ case yardman = "yardman"
651+ }
652+ }
653+
654+ enum Saccoderm: Codable {
655+ case integerArray([Int])
656+ case string(String)
657+ case null
658+
659+ init(from decoder: Decoder) throws {
660+ let container = try decoder.singleValueContainer()
661+ if let x = try? container.decode([Int].self) {
662+ self = .integerArray(x)
663+ return
664+ }
665+ if let x = try? container.decode(String.self) {
666+ self = .string(x)
667+ return
668+ }
669+ if container.decodeNil() {
670+ self = .null
671+ return
672+ }
673+ throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm"))
674+ }
675+
676+ func encode(to encoder: Encoder) throws {
677+ var container = encoder.singleValueContainer()
678+ switch self {
679+ case .integerArray(let x):
680+ try container.encode(x)
681+ case .string(let x):
682+ try container.encode(x)
683+ case .null:
684+ try container.encodeNil()
685+ }
686+ }
687+ }
688+
689+ enum SantirElement: Codable {
690+ case double(Double)
691+ case santirClass(TopLevel.SantirClass)
692+
693+ init(from decoder: Decoder) throws {
694+ let container = try decoder.singleValueContainer()
695+ if let x = try? container.decode(Double.self) {
696+ self = .double(x)
697+ return
698+ }
699+ if let x = try? container.decode(TopLevel.SantirClass.self) {
700+ self = .santirClass(x)
701+ return
702+ }
703+ throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement"))
704+ }
705+
706+ func encode(to encoder: Encoder) throws {
707+ var container = encoder.singleValueContainer()
708+ switch self {
709+ case .double(let x):
710+ try container.encode(x)
711+ case .santirClass(let x):
712+ try container.encode(x)
713+ }
714+ }
715+ }
716+
717+ struct SantirClass: Codable {
718+ let admiredly: JSONNull?
719+ let demicaponier: JSONNull?
720+ let epitympanic: JSONNull?
721+ let investitor: JSONNull?
722+ let lupiform: JSONNull?
723+ let monoflagellate: JSONNull?
724+ let paleoethnic: JSONNull?
725+ let prediscountable: JSONNull?
726+ let rhetoricals: JSONNull?
727+ let roomth: JSONNull?
728+ let saccharose: JSONNull?
729+ let septonasal: JSONNull?
730+ let serpenticide: JSONNull?
731+ let setarious: JSONNull?
732+ let spaework: JSONNull?
733+ let stylite: JSONNull?
734+ let suessiones: JSONNull?
735+ let timelily: JSONNull?
736+ let unprofaned: JSONNull?
737+ let vorticular: JSONNull?
738+
739+ enum CodingKeys: String, CodingKey {
740+ case admiredly = "admiredly"
741+ case demicaponier = "demicaponier"
742+ case epitympanic = "epitympanic"
743+ case investitor = "investitor"
744+ case lupiform = "lupiform"
745+ case monoflagellate = "monoflagellate"
746+ case paleoethnic = "paleoethnic"
747+ case prediscountable = "prediscountable"
748+ case rhetoricals = "rhetoricals"
749+ case roomth = "roomth"
750+ case saccharose = "saccharose"
751+ case septonasal = "septonasal"
752+ case serpenticide = "serpenticide"
753+ case setarious = "setarious"
754+ case spaework = "spaework"
755+ case stylite = "stylite"
756+ case suessiones = "Suessiones"
757+ case timelily = "timelily"
758+ case unprofaned = "unprofaned"
759+ case vorticular = "vorticular"
760+ }
761+ }
762+
763+ enum Saprophilous: Codable {
764+ case integerMap([String: Int])
765+ case string(String)
766+ case null
767+
768+ init(from decoder: Decoder) throws {
769+ let container = try decoder.singleValueContainer()
770+ if let x = try? container.decode([String: Int].self) {
771+ self = .integerMap(x)
772+ return
773+ }
774+ if let x = try? container.decode(String.self) {
775+ self = .string(x)
776+ return
777+ }
778+ if container.decodeNil() {
779+ self = .null
780+ return
781+ }
782+ throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous"))
783+ }
784+
785+ func encode(to encoder: Encoder) throws {
786+ var container = encoder.singleValueContainer()
787+ switch self {
788+ case .integerMap(let x):
789+ try container.encode(x)
790+ case .string(let x):
791+ try container.encode(x)
792+ case .null:
793+ try container.encodeNil()
794+ }
795+ }
796+ }
797+
798+ enum SaxtenElement: Codable {
799+ case saxtenClass(TopLevel.SaxtenClass)
800+ case string(String)
801+
802+ init(from decoder: Decoder) throws {
803+ let container = try decoder.singleValueContainer()
804+ if let x = try? container.decode(String.self) {
805+ self = .string(x)
806+ return
807+ }
808+ if let x = try? container.decode(TopLevel.SaxtenClass.self) {
809+ self = .saxtenClass(x)
810+ return
811+ }
812+ throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement"))
813+ }
814+
815+ func encode(to encoder: Encoder) throws {
816+ var container = encoder.singleValueContainer()
817+ switch self {
818+ case .saxtenClass(let x):
819+ try container.encode(x)
820+ case .string(let x):
821+ try container.encode(x)
822+ }
823+ }
824+ }
825+
826+ struct SaxtenClass: Codable {
827+ let algarrobilla: JSONNull?
828+ let bowgrace: JSONNull?
829+ let catharticalness: Double?
830+ let centaurid: JSONNull?
831+ let chirotherium: Int?
832+ let disdiapason: String?
833+ let flix: JSONNull?
834+ let germanely: JSONNull?
835+ let homocerc: Bool?
836+ let inhume: JSONNull?
837+ let lepidote: JSONNull?
838+ let megalochirous: JSONNull?
839+ let ninepenny: JSONNull?
840+ let nonbookish: JSONNull?
841+ let nondeist: JSONNull?
842+ let nymphaeaceous: JSONNull?
843+ let parietofrontal: JSONNull?
844+ let sancyite: JSONNull?
845+ let subjectivist: JSONNull?
846+ let tibiad: JSONNull?
847+ let transonic: JSONNull?
848+ let tripetalous: JSONNull?
849+ let trunchman: JSONNull?
850+ let urger: JSONNull?
851+ let withdrawnness: JSONNull?
852+
853+ enum CodingKeys: String, CodingKey {
854+ case algarrobilla = "algarrobilla"
855+ case bowgrace = "bowgrace"
856+ case catharticalness = "catharticalness"
857+ case centaurid = "Centaurid"
858+ case chirotherium = "Chirotherium"
859+ case disdiapason = "disdiapason"
860+ case flix = "flix"
861+ case germanely = "germanely"
862+ case homocerc = "homocerc"
863+ case inhume = "inhume"
864+ case lepidote = "lepidote"
865+ case megalochirous = "megalochirous"
866+ case ninepenny = "ninepenny"
867+ case nonbookish = "nonbookish"
868+ case nondeist = "nondeist"
869+ case nymphaeaceous = "nymphaeaceous"
870+ case parietofrontal = "parietofrontal"
871+ case sancyite = "sancyite"
872+ case subjectivist = "subjectivist"
873+ case tibiad = "tibiad"
874+ case transonic = "transonic"
875+ case tripetalous = "tripetalous"
876+ case trunchman = "trunchman"
877+ case urger = "urger"
878+ case withdrawnness = "withdrawnness"
879+ }
880+ }
881+
882+ struct Scatty: Codable {
883+ let aeriferous: JSONNull?
884+ let antical: JSONNull?
885+ let antighostism: JSONNull?
886+ let arcanum: JSONNull?
887+ let autotrophy: JSONNull?
888+ let baronial: JSONNull?
889+ let caffeine: JSONNull?
890+ let gorgoniacean: JSONNull?
891+ let heroical: JSONNull?
892+ let hydropical: JSONNull?
893+ let mechanology: JSONNull?
894+ let musicopoetic: JSONNull?
895+ let officiality: JSONNull?
896+ let oftentimes: JSONNull?
897+ let ophthalmotonometer: JSONNull?
898+ let reflectively: JSONNull?
899+ let springer: JSONNull?
900+ let tabasco: JSONNull?
901+ let teleianthous: JSONNull?
902+ let uncombated: JSONNull?
903+
904+ enum CodingKeys: String, CodingKey {
905+ case aeriferous = "aeriferous"
906+ case antical = "antical"
907+ case antighostism = "antighostism"
908+ case arcanum = "arcanum"
909+ case autotrophy = "autotrophy"
910+ case baronial = "baronial"
911+ case caffeine = "caffeine"
912+ case gorgoniacean = "gorgoniacean"
913+ case heroical = "heroical"
914+ case hydropical = "hydropical"
915+ case mechanology = "mechanology"
916+ case musicopoetic = "musicopoetic"
917+ case officiality = "officiality"
918+ case oftentimes = "oftentimes"
919+ case ophthalmotonometer = "ophthalmotonometer"
920+ case reflectively = "reflectively"
921+ case springer = "springer"
922+ case tabasco = "Tabasco"
923+ case teleianthous = "teleianthous"
924+ case uncombated = "uncombated"
925+ }
926+ }
927+
928+ enum Scoffer: Codable {
929+ case integerMap([String: Int])
930+ case nullArray([JSONNull?])
931+ case null
932+
933+ init(from decoder: Decoder) throws {
934+ let container = try decoder.singleValueContainer()
935+ if let x = try? container.decode([JSONNull?].self) {
936+ self = .nullArray(x)
937+ return
938+ }
939+ if let x = try? container.decode([String: Int].self) {
940+ self = .integerMap(x)
941+ return
942+ }
943+ if container.decodeNil() {
944+ self = .null
945+ return
946+ }
947+ throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer"))
948+ }
949+
950+ func encode(to encoder: Encoder) throws {
951+ var container = encoder.singleValueContainer()
952+ switch self {
953+ case .integerMap(let x):
954+ try container.encode(x)
955+ case .nullArray(let x):
956+ try container.encode(x)
957+ case .null:
958+ try container.encodeNil()
959+ }
960+ }
961+ }
962+
963+ enum Scrampum: Codable {
964+ case bool(Bool)
965+ case integerArray([Int])
966+ case null
967+
968+ init(from decoder: Decoder) throws {
969+ let container = try decoder.singleValueContainer()
970+ if let x = try? container.decode(Bool.self) {
971+ self = .bool(x)
972+ return
973+ }
974+ if let x = try? container.decode([Int].self) {
975+ self = .integerArray(x)
976+ return
977+ }
978+ if container.decodeNil() {
979+ self = .null
980+ return
981+ }
982+ throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum"))
983+ }
984+
985+ func encode(to encoder: Encoder) throws {
986+ var container = encoder.singleValueContainer()
987+ switch self {
988+ case .bool(let x):
989+ try container.encode(x)
990+ case .integerArray(let x):
991+ try container.encode(x)
992+ case .null:
993+ try container.encodeNil()
994+ }
995+ }
996+ }
997+
998+ enum Serpentinic: Codable {
999+ case double(Double)
1000+ case integerArray([Int])
1001+
1002+ init(from decoder: Decoder) throws {
1003+ let container = try decoder.singleValueContainer()
1004+ if let x = try? container.decode([Int].self) {
1005+ self = .integerArray(x)
1006+ return
1007+ }
1008+ if let x = try? container.decode(Double.self) {
1009+ self = .double(x)
1010+ return
1011+ }
1012+ throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic"))
1013+ }
1014+
1015+ func encode(to encoder: Encoder) throws {
1016+ var container = encoder.singleValueContainer()
1017+ switch self {
1018+ case .double(let x):
1019+ try container.encode(x)
1020+ case .integerArray(let x):
1021+ try container.encode(x)
1022+ }
1023+ }
1024+ }
1025+
1026+ enum Shadowable: Codable {
1027+ case bool(Bool)
1028+ case unionArray([Int?])
1029+
1030+ init(from decoder: Decoder) throws {
1031+ let container = try decoder.singleValueContainer()
1032+ if let x = try? container.decode(Bool.self) {
1033+ self = .bool(x)
1034+ return
1035+ }
1036+ if let x = try? container.decode([Int?].self) {
1037+ self = .unionArray(x)
1038+ return
1039+ }
1040+ throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable"))
1041+ }
1042+
1043+ func encode(to encoder: Encoder) throws {
1044+ var container = encoder.singleValueContainer()
1045+ switch self {
1046+ case .bool(let x):
1047+ try container.encode(x)
1048+ case .unionArray(let x):
1049+ try container.encode(x)
1050+ }
1051+ }
1052+ }
1053+
1054+ enum SisteringElement: Codable {
1055+ case integer(Int)
1056+ case nullArray([JSONNull?])
1057+ case sisteringClass(TopLevel.SisteringClass)
1058+
1059+ init(from decoder: Decoder) throws {
1060+ let container = try decoder.singleValueContainer()
1061+ if let x = try? container.decode(Int.self) {
1062+ self = .integer(x)
1063+ return
1064+ }
1065+ if let x = try? container.decode([JSONNull?].self) {
1066+ self = .nullArray(x)
1067+ return
1068+ }
1069+ if let x = try? container.decode(TopLevel.SisteringClass.self) {
1070+ self = .sisteringClass(x)
1071+ return
1072+ }
1073+ throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement"))
1074+ }
1075+
1076+ func encode(to encoder: Encoder) throws {
1077+ var container = encoder.singleValueContainer()
1078+ switch self {
1079+ case .integer(let x):
1080+ try container.encode(x)
1081+ case .nullArray(let x):
1082+ try container.encode(x)
1083+ case .sisteringClass(let x):
1084+ try container.encode(x)
1085+ }
1086+ }
1087+ }
1088+
1089+ struct SisteringClass: Codable {
1090+ let amphicarpic: JSONNull?
1091+ let chianti: JSONNull?
1092+ let frigorific: JSONNull?
1093+ let haplomi: JSONNull?
1094+ let hyperkinesis: JSONNull?
1095+ let laudable: JSONNull?
1096+ let madwoman: JSONNull?
1097+ let maimedly: JSONNull?
1098+ let micropterygidae: JSONNull?
1099+ let microrhabdus: JSONNull?
1100+ let nondense: JSONNull?
1101+ let phlebemphraxis: JSONNull?
1102+ let redsear: JSONNull?
1103+ let schismatical: JSONNull?
1104+ let tartryl: JSONNull?
1105+ let unabhorred: JSONNull?
1106+ let undeliberateness: JSONNull?
1107+ let unmixable: JSONNull?
1108+ let untruckling: JSONNull?
1109+ let vineal: JSONNull?
1110+
1111+ enum CodingKeys: String, CodingKey {
1112+ case amphicarpic = "amphicarpic"
1113+ case chianti = "Chianti"
1114+ case frigorific = "frigorific"
1115+ case haplomi = "Haplomi"
1116+ case hyperkinesis = "hyperkinesis"
1117+ case laudable = "laudable"
1118+ case madwoman = "madwoman"
1119+ case maimedly = "maimedly"
1120+ case micropterygidae = "Micropterygidae"
1121+ case microrhabdus = "microrhabdus"
1122+ case nondense = "nondense"
1123+ case phlebemphraxis = "phlebemphraxis"
1124+ case redsear = "redsear"
1125+ case schismatical = "schismatical"
1126+ case tartryl = "tartryl"
1127+ case unabhorred = "unabhorred"
1128+ case undeliberateness = "undeliberateness"
1129+ case unmixable = "unmixable"
1130+ case untruckling = "untruckling"
1131+ case vineal = "vineal"
1132+ }
1133+ }
1134+
1135+ struct Staghunting: Codable {
1136+ let calorimetric: Int?
1137+ let canid: Int?
1138+ let catharticalness: Double?
1139+ let chirotherium: Int?
1140+ let disdiapason: String?
1141+ let ditriglyphic: Int?
1142+ let floriferousness: Int?
1143+ let gamelike: Int?
1144+ let grig: Int?
1145+ let homocerc: Bool?
1146+ let interloan: Int?
1147+ let lithotomy: Int?
1148+ let loric: Int?
1149+ let membranocoriaceous: Int?
1150+ let membranogenic: Int?
1151+ let nonbookish: JSONNull?
1152+ let overtrump: Int?
1153+ let scotino: Int?
1154+ let seasonable: Int?
1155+ let sephen: Int?
1156+ let stigmarioid: Int?
1157+ let tired: Int?
1158+ let trifid: Int?
1159+ let undefeatedly: Int?
1160+ let ungirlish: Int?
1161+
1162+ enum CodingKeys: String, CodingKey {
1163+ case calorimetric = "calorimetric"
1164+ case canid = "canid"
1165+ case catharticalness = "catharticalness"
1166+ case chirotherium = "Chirotherium"
1167+ case disdiapason = "disdiapason"
1168+ case ditriglyphic = "ditriglyphic"
1169+ case floriferousness = "floriferousness"
1170+ case gamelike = "gamelike"
1171+ case grig = "grig"
1172+ case homocerc = "homocerc"
1173+ case interloan = "interloan"
1174+ case lithotomy = "lithotomy"
1175+ case loric = "loric"
1176+ case membranocoriaceous = "membranocoriaceous"
1177+ case membranogenic = "membranogenic"
1178+ case nonbookish = "nonbookish"
1179+ case overtrump = "overtrump"
1180+ case scotino = "scotino"
1181+ case seasonable = "seasonable"
1182+ case sephen = "sephen"
1183+ case stigmarioid = "stigmarioid"
1184+ case tired = "tired"
1185+ case trifid = "trifid"
1186+ case undefeatedly = "undefeatedly"
1187+ case ungirlish = "ungirlish"
1188+ }
1189+ }
1190+
1191+ enum Stagmometer: Codable {
1192+ case string(String)
1193+ case unionArray([Int?])
1194+
1195+ init(from decoder: Decoder) throws {
1196+ let container = try decoder.singleValueContainer()
1197+ if let x = try? container.decode([Int?].self) {
1198+ self = .unionArray(x)
1199+ return
1200+ }
1201+ if let x = try? container.decode(String.self) {
1202+ self = .string(x)
1203+ return
1204+ }
1205+ throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer"))
1206+ }
1207+
1208+ func encode(to encoder: Encoder) throws {
1209+ var container = encoder.singleValueContainer()
1210+ switch self {
1211+ case .string(let x):
1212+ try container.encode(x)
1213+ case .unionArray(let x):
1214+ try container.encode(x)
1215+ }
1216+ }
1217+ }
1218+
1219+ enum Stimulability: Codable {
1220+ case bool(Bool)
1221+ case integer(Int)
1222+ case integerMap([String: Int])
1223+
1224+ init(from decoder: Decoder) throws {
1225+ let container = try decoder.singleValueContainer()
1226+ if let x = try? container.decode(Bool.self) {
1227+ self = .bool(x)
1228+ return
1229+ }
1230+ if let x = try? container.decode(Int.self) {
1231+ self = .integer(x)
1232+ return
1233+ }
1234+ if let x = try? container.decode([String: Int].self) {
1235+ self = .integerMap(x)
1236+ return
1237+ }
1238+ throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability"))
1239+ }
1240+
1241+ func encode(to encoder: Encoder) throws {
1242+ var container = encoder.singleValueContainer()
1243+ switch self {
1244+ case .bool(let x):
1245+ try container.encode(x)
1246+ case .integer(let x):
1247+ try container.encode(x)
1248+ case .integerMap(let x):
1249+ try container.encode(x)
1250+ }
1251+ }
1252+ }
1253+
1254+ enum Strangleable: Codable {
1255+ case double(Double)
1256+ case nullArray([JSONNull?])
1257+
1258+ init(from decoder: Decoder) throws {
1259+ let container = try decoder.singleValueContainer()
1260+ if let x = try? container.decode([JSONNull?].self) {
1261+ self = .nullArray(x)
1262+ return
1263+ }
1264+ if let x = try? container.decode(Double.self) {
1265+ self = .double(x)
1266+ return
1267+ }
1268+ throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable"))
1269+ }
1270+
1271+ func encode(to encoder: Encoder) throws {
1272+ var container = encoder.singleValueContainer()
1273+ switch self {
1274+ case .double(let x):
1275+ try container.encode(x)
1276+ case .nullArray(let x):
1277+ try container.encode(x)
1278+ }
1279+ }
1280+ }
1281+
1282+ enum StrenuosityElement: Codable {
1283+ case nullArray([JSONNull?])
1284+ case strenuosityClass(TopLevel.StrenuosityClass)
1285+
1286+ init(from decoder: Decoder) throws {
1287+ let container = try decoder.singleValueContainer()
1288+ if let x = try? container.decode([JSONNull?].self) {
1289+ self = .nullArray(x)
1290+ return
1291+ }
1292+ if let x = try? container.decode(TopLevel.StrenuosityClass.self) {
1293+ self = .strenuosityClass(x)
1294+ return
1295+ }
1296+ throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement"))
1297+ }
1298+
1299+ func encode(to encoder: Encoder) throws {
1300+ var container = encoder.singleValueContainer()
1301+ switch self {
1302+ case .nullArray(let x):
1303+ try container.encode(x)
1304+ case .strenuosityClass(let x):
1305+ try container.encode(x)
1306+ }
1307+ }
1308+ }
1309+
1310+ struct StrenuosityClass: Codable {
1311+ let bliss: Int?
1312+ let buccate: Int?
1313+ let bulletproof: Int?
1314+ let catharticalness: Double?
1315+ let chirotherium: Int?
1316+ let crumblingness: Int?
1317+ let disdiapason: String?
1318+ let engagedly: Int?
1319+ let fightable: Int?
1320+ let hoariness: Int?
1321+ let homocerc: Bool?
1322+ let hypopodium: Int?
1323+ let luxurist: Int?
1324+ let mechanician: Int?
1325+ let nonbookish: JSONNull?
1326+ let onopordon: Int?
1327+ let podgily: Int?
1328+ let reformableness: Int?
1329+ let scatterbrains: Int?
1330+ let seminuria: Int?
1331+ let sodomite: Int?
1332+ let tramp: Int?
1333+ let undueness: Int?
1334+ let worthily: Int?
1335+ let yankeeist: Int?
1336+
1337+ enum CodingKeys: String, CodingKey {
1338+ case bliss = "bliss"
1339+ case buccate = "buccate"
1340+ case bulletproof = "bulletproof"
1341+ case catharticalness = "catharticalness"
1342+ case chirotherium = "Chirotherium"
1343+ case crumblingness = "crumblingness"
1344+ case disdiapason = "disdiapason"
1345+ case engagedly = "engagedly"
1346+ case fightable = "fightable"
1347+ case hoariness = "hoariness"
1348+ case homocerc = "homocerc"
1349+ case hypopodium = "hypopodium"
1350+ case luxurist = "luxurist"
1351+ case mechanician = "mechanician"
1352+ case nonbookish = "nonbookish"
1353+ case onopordon = "Onopordon"
1354+ case podgily = "podgily"
1355+ case reformableness = "reformableness"
1356+ case scatterbrains = "scatterbrains"
1357+ case seminuria = "seminuria"
1358+ case sodomite = "Sodomite"
1359+ case tramp = "tramp"
1360+ case undueness = "undueness"
1361+ case worthily = "worthily"
1362+ case yankeeist = "Yankeeist"
1363+ }
1364+ }
1365+
1366+ enum Tabaxir: Codable {
1367+ case bool(Bool)
1368+ case double(Double)
1369+
1370+ init(from decoder: Decoder) throws {
1371+ let container = try decoder.singleValueContainer()
1372+ if let x = try? container.decode(Bool.self) {
1373+ self = .bool(x)
1374+ return
1375+ }
1376+ if let x = try? container.decode(Double.self) {
1377+ self = .double(x)
1378+ return
1379+ }
1380+ throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir"))
1381+ }
1382+
1383+ func encode(to encoder: Encoder) throws {
1384+ var container = encoder.singleValueContainer()
1385+ switch self {
1386+ case .bool(let x):
1387+ try container.encode(x)
1388+ case .double(let x):
1389+ try container.encode(x)
1390+ }
1391+ }
1392+ }
1393+
1394+ enum Talpiform: Codable {
1395+ case double(Double)
1396+ case quebrachineClass(TopLevel.QuebrachineClass)
1397+ case null
1398+
1399+ init(from decoder: Decoder) throws {
1400+ let container = try decoder.singleValueContainer()
1401+ if let x = try? container.decode(Double.self) {
1402+ self = .double(x)
1403+ return
1404+ }
1405+ if let x = try? container.decode(TopLevel.QuebrachineClass.self) {
1406+ self = .quebrachineClass(x)
1407+ return
1408+ }
1409+ if container.decodeNil() {
1410+ self = .null
1411+ return
1412+ }
1413+ throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform"))
1414+ }
1415+
1416+ func encode(to encoder: Encoder) throws {
1417+ var container = encoder.singleValueContainer()
1418+ switch self {
1419+ case .double(let x):
1420+ try container.encode(x)
1421+ case .quebrachineClass(let x):
1422+ try container.encode(x)
1423+ case .null:
1424+ try container.encodeNil()
1425+ }
1426+ }
1427+ }
1428+
1429+ enum Thwack: Codable {
1430+ case bool(Bool)
1431+ case double(Double)
1432+ case quebrachineClass(TopLevel.QuebrachineClass)
1433+
1434+ init(from decoder: Decoder) throws {
1435+ let container = try decoder.singleValueContainer()
1436+ if let x = try? container.decode(Bool.self) {
1437+ self = .bool(x)
1438+ return
1439+ }
1440+ if let x = try? container.decode(Double.self) {
1441+ self = .double(x)
1442+ return
1443+ }
1444+ if let x = try? container.decode(TopLevel.QuebrachineClass.self) {
1445+ self = .quebrachineClass(x)
1446+ return
1447+ }
1448+ throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack"))
1449+ }
1450+
1451+ func encode(to encoder: Encoder) throws {
1452+ var container = encoder.singleValueContainer()
1453+ switch self {
1454+ case .bool(let x):
1455+ try container.encode(x)
1456+ case .double(let x):
1457+ try container.encode(x)
1458+ case .quebrachineClass(let x):
1459+ try container.encode(x)
1460+ }
1461+ }
1462+ }
1463+
1464+ enum Tortricine: Codable {
1465+ case quebrachineClass(TopLevel.QuebrachineClass)
1466+ case unionArray([Int?])
1467+
1468+ init(from decoder: Decoder) throws {
1469+ let container = try decoder.singleValueContainer()
1470+ if let x = try? container.decode([Int?].self) {
1471+ self = .unionArray(x)
1472+ return
1473+ }
1474+ if let x = try? container.decode(TopLevel.QuebrachineClass.self) {
1475+ self = .quebrachineClass(x)
1476+ return
1477+ }
1478+ throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine"))
1479+ }
1480+
1481+ func encode(to encoder: Encoder) throws {
1482+ var container = encoder.singleValueContainer()
1483+ switch self {
1484+ case .quebrachineClass(let x):
1485+ try container.encode(x)
1486+ case .unionArray(let x):
1487+ try container.encode(x)
1488+ }
1489+ }
1490+ }
1491+
1492+ enum TruantcyElement: Codable {
1493+ case bool(Bool)
1494+ case truantcyClass(TopLevel.TruantcyClass)
1495+
1496+ init(from decoder: Decoder) throws {
1497+ let container = try decoder.singleValueContainer()
1498+ if let x = try? container.decode(Bool.self) {
1499+ self = .bool(x)
1500+ return
1501+ }
1502+ if let x = try? container.decode(TopLevel.TruantcyClass.self) {
1503+ self = .truantcyClass(x)
1504+ return
1505+ }
1506+ throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement"))
1507+ }
1508+
1509+ func encode(to encoder: Encoder) throws {
1510+ var container = encoder.singleValueContainer()
1511+ switch self {
1512+ case .bool(let x):
1513+ try container.encode(x)
1514+ case .truantcyClass(let x):
1515+ try container.encode(x)
1516+ }
1517+ }
1518+ }
1519+
1520+ struct TruantcyClass: Codable {
1521+ let alfiona: JSONNull?
1522+ let ascaridiasis: JSONNull?
1523+ let bungey: JSONNull?
1524+ let catharticalness: Double?
1525+ let ceroxyle: JSONNull?
1526+ let chirotherium: Int?
1527+ let chorology: JSONNull?
1528+ let disdiapason: String?
1529+ let enmarble: JSONNull?
1530+ let epeira: JSONNull?
1531+ let eurylaimi: JSONNull?
1532+ let germination: JSONNull?
1533+ let hallelujah: JSONNull?
1534+ let homocerc: Bool?
1535+ let lev: JSONNull?
1536+ let mouthing: JSONNull?
1537+ let nonbookish: JSONNull?
1538+ let philliloo: JSONNull?
1539+ let planetal: JSONNull?
1540+ let poney: JSONNull?
1541+ let punctualist: JSONNull?
1542+ let returnlessly: JSONNull?
1543+ let skelder: JSONNull?
1544+ let windwaywardly: JSONNull?
1545+ let yuman: JSONNull?
1546+
1547+ enum CodingKeys: String, CodingKey {
1548+ case alfiona = "alfiona"
1549+ case ascaridiasis = "ascaridiasis"
1550+ case bungey = "bungey"
1551+ case catharticalness = "catharticalness"
1552+ case ceroxyle = "ceroxyle"
1553+ case chirotherium = "Chirotherium"
1554+ case chorology = "chorology"
1555+ case disdiapason = "disdiapason"
1556+ case enmarble = "enmarble"
1557+ case epeira = "Epeira"
1558+ case eurylaimi = "Eurylaimi"
1559+ case germination = "germination"
1560+ case hallelujah = "hallelujah"
1561+ case homocerc = "homocerc"
1562+ case lev = "lev"
1563+ case mouthing = "mouthing"
1564+ case nonbookish = "nonbookish"
1565+ case philliloo = "philliloo"
1566+ case planetal = "planetal"
1567+ case poney = "poney"
1568+ case punctualist = "punctualist"
1569+ case returnlessly = "returnlessly"
1570+ case skelder = "skelder"
1571+ case windwaywardly = "windwaywardly"
1572+ case yuman = "Yuman"
1573+ }
1574+ }
1575+
1576+ enum Unbeginning: Codable {
1577+ case integerMap([String: Int])
1578+ case nullArray([JSONNull?])
1579+ case string(String)
1580+
1581+ init(from decoder: Decoder) throws {
1582+ let container = try decoder.singleValueContainer()
1583+ if let x = try? container.decode([JSONNull?].self) {
1584+ self = .nullArray(x)
1585+ return
1586+ }
1587+ if let x = try? container.decode([String: Int].self) {
1588+ self = .integerMap(x)
1589+ return
1590+ }
1591+ if let x = try? container.decode(String.self) {
1592+ self = .string(x)
1593+ return
1594+ }
1595+ throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning"))
1596+ }
1597+
1598+ func encode(to encoder: Encoder) throws {
1599+ var container = encoder.singleValueContainer()
1600+ switch self {
1601+ case .integerMap(let x):
1602+ try container.encode(x)
1603+ case .nullArray(let x):
1604+ try container.encode(x)
1605+ case .string(let x):
1606+ try container.encode(x)
1607+ }
1608+ }
1609+ }
1610+
1611+ enum Undesirability: Codable {
1612+ case integerArray([Int])
1613+ case integerMap([String: Int])
1614+ case string(String)
1615+
1616+ init(from decoder: Decoder) throws {
1617+ let container = try decoder.singleValueContainer()
1618+ if let x = try? container.decode([Int].self) {
1619+ self = .integerArray(x)
1620+ return
1621+ }
1622+ if let x = try? container.decode([String: Int].self) {
1623+ self = .integerMap(x)
1624+ return
1625+ }
1626+ if let x = try? container.decode(String.self) {
1627+ self = .string(x)
1628+ return
1629+ }
1630+ throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability"))
1631+ }
1632+
1633+ func encode(to encoder: Encoder) throws {
1634+ var container = encoder.singleValueContainer()
1635+ switch self {
1636+ case .integerArray(let x):
1637+ try container.encode(x)
1638+ case .integerMap(let x):
1639+ try container.encode(x)
1640+ case .string(let x):
1641+ try container.encode(x)
1642+ }
1643+ }
1644+ }
1645+
1646+ enum Unerasing: Codable {
1647+ case integer(Int)
1648+ case integerMap([String: Int])
1649+ case nullArray([JSONNull?])
1650+
1651+ init(from decoder: Decoder) throws {
1652+ let container = try decoder.singleValueContainer()
1653+ if let x = try? container.decode(Int.self) {
1654+ self = .integer(x)
1655+ return
1656+ }
1657+ if let x = try? container.decode([JSONNull?].self) {
1658+ self = .nullArray(x)
1659+ return
1660+ }
1661+ if let x = try? container.decode([String: Int].self) {
1662+ self = .integerMap(x)
1663+ return
1664+ }
1665+ throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing"))
1666+ }
1667+
1668+ func encode(to encoder: Encoder) throws {
1669+ var container = encoder.singleValueContainer()
1670+ switch self {
1671+ case .integer(let x):
1672+ try container.encode(x)
1673+ case .integerMap(let x):
1674+ try container.encode(x)
1675+ case .nullArray(let x):
1676+ try container.encode(x)
1677+ }
1678+ }
1679+ }
1680+
1681+ enum Unguentarium: Codable {
1682+ case integer(Int)
1683+ case nullArray([JSONNull?])
1684+ case null
1685+
1686+ init(from decoder: Decoder) throws {
1687+ let container = try decoder.singleValueContainer()
1688+ if let x = try? container.decode(Int.self) {
1689+ self = .integer(x)
1690+ return
1691+ }
1692+ if let x = try? container.decode([JSONNull?].self) {
1693+ self = .nullArray(x)
1694+ return
1695+ }
1696+ if container.decodeNil() {
1697+ self = .null
1698+ return
1699+ }
1700+ throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium"))
1701+ }
1702+
1703+ func encode(to encoder: Encoder) throws {
1704+ var container = encoder.singleValueContainer()
1705+ switch self {
1706+ case .integer(let x):
1707+ try container.encode(x)
1708+ case .nullArray(let x):
1709+ try container.encode(x)
1710+ case .null:
1711+ try container.encodeNil()
1712+ }
1713+ }
1714+ }
1715+
1716+ enum UnimpeachablyElement: Codable {
1717+ case bool(Bool)
1718+ case unimpeachablyClass(TopLevel.UnimpeachablyClass)
1719+
1720+ init(from decoder: Decoder) throws {
1721+ let container = try decoder.singleValueContainer()
1722+ if let x = try? container.decode(Bool.self) {
1723+ self = .bool(x)
1724+ return
1725+ }
1726+ if let x = try? container.decode(TopLevel.UnimpeachablyClass.self) {
1727+ self = .unimpeachablyClass(x)
1728+ return
1729+ }
1730+ throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement"))
1731+ }
1732+
1733+ func encode(to encoder: Encoder) throws {
1734+ var container = encoder.singleValueContainer()
1735+ switch self {
1736+ case .bool(let x):
1737+ try container.encode(x)
1738+ case .unimpeachablyClass(let x):
1739+ try container.encode(x)
1740+ }
1741+ }
1742+ }
1743+
1744+ struct UnimpeachablyClass: Codable {
1745+ let acerin: Int?
1746+ let bobadil: Int?
1747+ let catharticalness: Double?
1748+ let chirotherium: Int?
1749+ let chlorophylligenous: Int?
1750+ let conversational: Int?
1751+ let demiowl: Int?
1752+ let disdiapason: String?
1753+ let ectorhinal: Int?
1754+ let gamblesomeness: Int?
1755+ let homocerc: Bool?
1756+ let irrorate: Int?
1757+ let kindergartening: Int?
1758+ let lateritic: Int?
1759+ let mespil: Int?
1760+ let misconfiguration: Int?
1761+ let nonbookish: JSONNull?
1762+ let planometry: Int?
1763+ let quiina: Int?
1764+ let robert: Int?
1765+ let rot: Int?
1766+ let subcinctorium: Int?
1767+ let tussocker: Int?
1768+ let ultraproud: Int?
1769+ let unsuggestedness: Int?
1770+
1771+ enum CodingKeys: String, CodingKey {
1772+ case acerin = "acerin"
1773+ case bobadil = "Bobadil"
1774+ case catharticalness = "catharticalness"
1775+ case chirotherium = "Chirotherium"
1776+ case chlorophylligenous = "chlorophylligenous"
1777+ case conversational = "conversational"
1778+ case demiowl = "demiowl"
1779+ case disdiapason = "disdiapason"
1780+ case ectorhinal = "ectorhinal"
1781+ case gamblesomeness = "gamblesomeness"
1782+ case homocerc = "homocerc"
1783+ case irrorate = "irrorate"
1784+ case kindergartening = "kindergartening"
1785+ case lateritic = "lateritic"
1786+ case mespil = "mespil"
1787+ case misconfiguration = "misconfiguration"
1788+ case nonbookish = "nonbookish"
1789+ case planometry = "planometry"
1790+ case quiina = "Quiina"
1791+ case robert = "Robert"
1792+ case rot = "rot"
1793+ case subcinctorium = "subcinctorium"
1794+ case tussocker = "tussocker"
1795+ case ultraproud = "ultraproud"
1796+ case unsuggestedness = "unsuggestedness"
1797+ }
1798+ }
1799+
1800+ enum Unmortgaged: Codable {
1801+ case double(Double)
1802+ case integerMap([String: Int])
1803+ case null
1804+
1805+ init(from decoder: Decoder) throws {
1806+ let container = try decoder.singleValueContainer()
1807+ if let x = try? container.decode(Double.self) {
1808+ self = .double(x)
1809+ return
1810+ }
1811+ if let x = try? container.decode([String: Int].self) {
1812+ self = .integerMap(x)
1813+ return
1814+ }
1815+ if container.decodeNil() {
1816+ self = .null
1817+ return
1818+ }
1819+ throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged"))
1820+ }
1821+
1822+ func encode(to encoder: Encoder) throws {
1823+ var container = encoder.singleValueContainer()
1824+ switch self {
1825+ case .double(let x):
1826+ try container.encode(x)
1827+ case .integerMap(let x):
1828+ try container.encode(x)
1829+ case .null:
1830+ try container.encodeNil()
1831+ }
1832+ }
1833+ }
1834+
1835+ enum Unobstructed: Codable {
1836+ case integer(Int)
1837+ case quebrachineClass(TopLevel.QuebrachineClass)
1838+ case null
1839+
1840+ init(from decoder: Decoder) throws {
1841+ let container = try decoder.singleValueContainer()
1842+ if let x = try? container.decode(Int.self) {
1843+ self = .integer(x)
1844+ return
1845+ }
1846+ if let x = try? container.decode(TopLevel.QuebrachineClass.self) {
1847+ self = .quebrachineClass(x)
1848+ return
1849+ }
1850+ if container.decodeNil() {
1851+ self = .null
1852+ return
1853+ }
1854+ throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed"))
1855+ }
1856+
1857+ func encode(to encoder: Encoder) throws {
1858+ var container = encoder.singleValueContainer()
1859+ switch self {
1860+ case .integer(let x):
1861+ try container.encode(x)
1862+ case .quebrachineClass(let x):
1863+ try container.encode(x)
1864+ case .null:
1865+ try container.encodeNil()
1866+ }
1867+ }
1868+ }
1869+
1870+ enum Unreceptivity: Codable {
1871+ case integer(Int)
1872+ case nullArray([JSONNull?])
1873+ case string(String)
1874+
1875+ init(from decoder: Decoder) throws {
1876+ let container = try decoder.singleValueContainer()
1877+ if let x = try? container.decode(Int.self) {
1878+ self = .integer(x)
1879+ return
1880+ }
1881+ if let x = try? container.decode([JSONNull?].self) {
1882+ self = .nullArray(x)
1883+ return
1884+ }
1885+ if let x = try? container.decode(String.self) {
1886+ self = .string(x)
1887+ return
1888+ }
1889+ throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity"))
1890+ }
1891+
1892+ func encode(to encoder: Encoder) throws {
1893+ var container = encoder.singleValueContainer()
1894+ switch self {
1895+ case .integer(let x):
1896+ try container.encode(x)
1897+ case .nullArray(let x):
1898+ try container.encode(x)
1899+ case .string(let x):
1900+ try container.encode(x)
1901+ }
1902+ }
1903+ }
1904+
1905+ enum Unsatisfactoriness: Codable {
1906+ case bool(Bool)
1907+ case integer(Int)
1908+ case integerArray([Int])
1909+
1910+ init(from decoder: Decoder) throws {
1911+ let container = try decoder.singleValueContainer()
1912+ if let x = try? container.decode(Bool.self) {
1913+ self = .bool(x)
1914+ return
1915+ }
1916+ if let x = try? container.decode(Int.self) {
1917+ self = .integer(x)
1918+ return
1919+ }
1920+ if let x = try? container.decode([Int].self) {
1921+ self = .integerArray(x)
1922+ return
1923+ }
1924+ throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness"))
1925+ }
1926+
1927+ func encode(to encoder: Encoder) throws {
1928+ var container = encoder.singleValueContainer()
1929+ switch self {
1930+ case .bool(let x):
1931+ try container.encode(x)
1932+ case .integer(let x):
1933+ try container.encode(x)
1934+ case .integerArray(let x):
1935+ try container.encode(x)
1936+ }
1937+ }
1938+ }
1939+
1940+ enum UnstressedElement: Codable {
1941+ case bool(Bool)
1942+ case string(String)
1943+ case unstressedClass(TopLevel.UnstressedClass)
1944+
1945+ init(from decoder: Decoder) throws {
1946+ let container = try decoder.singleValueContainer()
1947+ if let x = try? container.decode(Bool.self) {
1948+ self = .bool(x)
1949+ return
1950+ }
1951+ if let x = try? container.decode(String.self) {
1952+ self = .string(x)
1953+ return
1954+ }
1955+ if let x = try? container.decode(TopLevel.UnstressedClass.self) {
1956+ self = .unstressedClass(x)
1957+ return
1958+ }
1959+ throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement"))
1960+ }
1961+
1962+ func encode(to encoder: Encoder) throws {
1963+ var container = encoder.singleValueContainer()
1964+ switch self {
1965+ case .bool(let x):
1966+ try container.encode(x)
1967+ case .string(let x):
1968+ try container.encode(x)
1969+ case .unstressedClass(let x):
1970+ try container.encode(x)
1971+ }
1972+ }
1973+ }
1974+
1975+ struct UnstressedClass: Codable {
1976+ let alain: JSONNull?
1977+ let amphirhina: JSONNull?
1978+ let antimachinery: JSONNull?
1979+ let coldish: JSONNull?
1980+ let crantara: JSONNull?
1981+ let distinguishing: JSONNull?
1982+ let elytroposis: JSONNull?
1983+ let gentianwort: JSONNull?
1984+ let heliosis: JSONNull?
1985+ let instrumental: JSONNull?
1986+ let introinflection: JSONNull?
1987+ let kala: JSONNull?
1988+ let lincolnian: JSONNull?
1989+ let metad: JSONNull?
1990+ let sarcophilus: JSONNull?
1991+ let swingingly: JSONNull?
1992+ let unconformity: JSONNull?
1993+ let undecreed: JSONNull?
1994+ let venerable: JSONNull?
1995+ let vowellessness: JSONNull?
1996+
1997+ enum CodingKeys: String, CodingKey {
1998+ case alain = "Alain"
1999+ case amphirhina = "Amphirhina"
2000+ case antimachinery = "antimachinery"
2001+ case coldish = "coldish"
2002+ case crantara = "crantara"
2003+ case distinguishing = "distinguishing"
2004+ case elytroposis = "elytroposis"
2005+ case gentianwort = "gentianwort"
2006+ case heliosis = "heliosis"
2007+ case instrumental = "instrumental"
2008+ case introinflection = "introinflection"
2009+ case kala = "kala"
2010+ case lincolnian = "Lincolnian"
2011+ case metad = "metad"
2012+ case sarcophilus = "Sarcophilus"
2013+ case swingingly = "swingingly"
2014+ case unconformity = "unconformity"
2015+ case undecreed = "undecreed"
2016+ case venerable = "venerable"
2017+ case vowellessness = "vowellessness"
2018+ }
2019+ }
2020+
2021+ enum Untasked: Codable {
2022+ case double(Double)
2023+ case integerMap([String: Int])
2024+ case nullArray([JSONNull?])
2025+
2026+ init(from decoder: Decoder) throws {
2027+ let container = try decoder.singleValueContainer()
2028+ if let x = try? container.decode([JSONNull?].self) {
2029+ self = .nullArray(x)
2030+ return
2031+ }
2032+ if let x = try? container.decode(Double.self) {
2033+ self = .double(x)
2034+ return
2035+ }
2036+ if let x = try? container.decode([String: Int].self) {
2037+ self = .integerMap(x)
2038+ return
2039+ }
2040+ throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked"))
2041+ }
2042+
2043+ func encode(to encoder: Encoder) throws {
2044+ var container = encoder.singleValueContainer()
2045+ switch self {
2046+ case .double(let x):
2047+ try container.encode(x)
2048+ case .integerMap(let x):
2049+ try container.encode(x)
2050+ case .nullArray(let x):
2051+ try container.encode(x)
2052+ }
2053+ }
2054+ }
2055+
2056+ enum Unvarying: Codable {
2057+ case bool(Bool)
2058+ case double(Double)
2059+ case integerMap([String: Int])
2060+
2061+ init(from decoder: Decoder) throws {
2062+ let container = try decoder.singleValueContainer()
2063+ if let x = try? container.decode(Bool.self) {
2064+ self = .bool(x)
2065+ return
2066+ }
2067+ if let x = try? container.decode(Double.self) {
2068+ self = .double(x)
2069+ return
2070+ }
2071+ if let x = try? container.decode([String: Int].self) {
2072+ self = .integerMap(x)
2073+ return
2074+ }
2075+ throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying"))
2076+ }
2077+
2078+ func encode(to encoder: Encoder) throws {
2079+ var container = encoder.singleValueContainer()
2080+ switch self {
2081+ case .bool(let x):
2082+ try container.encode(x)
2083+ case .double(let x):
2084+ try container.encode(x)
2085+ case .integerMap(let x):
2086+ try container.encode(x)
2087+ }
2088+ }
2089+ }
2090+
2091+ enum Vehemently: Codable {
2092+ case bool(Bool)
2093+ case nullArray([JSONNull?])
2094+ case null
2095+
2096+ init(from decoder: Decoder) throws {
2097+ let container = try decoder.singleValueContainer()
2098+ if let x = try? container.decode(Bool.self) {
2099+ self = .bool(x)
2100+ return
2101+ }
2102+ if let x = try? container.decode([JSONNull?].self) {
2103+ self = .nullArray(x)
2104+ return
2105+ }
2106+ if container.decodeNil() {
2107+ self = .null
2108+ return
2109+ }
2110+ throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently"))
2111+ }
2112+
2113+ func encode(to encoder: Encoder) throws {
2114+ var container = encoder.singleValueContainer()
2115+ switch self {
2116+ case .bool(let x):
2117+ try container.encode(x)
2118+ case .nullArray(let x):
2119+ try container.encode(x)
2120+ case .null:
2121+ try container.encodeNil()
2122+ }
2123+ }
2124+ }
2125+
2126+ enum Whitepot: Codable {
2127+ case double(Double)
2128+ case quebrachineClass(TopLevel.QuebrachineClass)
2129+
2130+ init(from decoder: Decoder) throws {
2131+ let container = try decoder.singleValueContainer()
2132+ if let x = try? container.decode(Double.self) {
2133+ self = .double(x)
2134+ return
2135+ }
2136+ if let x = try? container.decode(TopLevel.QuebrachineClass.self) {
2137+ self = .quebrachineClass(x)
2138+ return
2139+ }
2140+ throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot"))
2141+ }
2142+
2143+ func encode(to encoder: Encoder) throws {
2144+ var container = encoder.singleValueContainer()
2145+ switch self {
2146+ case .double(let x):
2147+ try container.encode(x)
2148+ case .quebrachineClass(let x):
2149+ try container.encode(x)
2150+ }
2151+ }
2152+ }
2153+
2154+ enum WrothyElement: Codable {
2155+ case nullArray([JSONNull?])
2156+ case wrothyClass(TopLevel.WrothyClass)
2157+
2158+ init(from decoder: Decoder) throws {
2159+ let container = try decoder.singleValueContainer()
2160+ if let x = try? container.decode([JSONNull?].self) {
2161+ self = .nullArray(x)
2162+ return
2163+ }
2164+ if let x = try? container.decode(TopLevel.WrothyClass.self) {
2165+ self = .wrothyClass(x)
2166+ return
2167+ }
2168+ throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement"))
2169+ }
2170+
2171+ func encode(to encoder: Encoder) throws {
2172+ var container = encoder.singleValueContainer()
2173+ switch self {
2174+ case .nullArray(let x):
2175+ try container.encode(x)
2176+ case .wrothyClass(let x):
2177+ try container.encode(x)
2178+ }
2179+ }
2180+ }
2181+
2182+ struct WrothyClass: Codable {
2183+ let aeschynanthus: JSONNull?
2184+ let aquiferous: JSONNull?
2185+ let cheapener: JSONNull?
2186+ let enumeration: JSONNull?
2187+ let ephesine: JSONNull?
2188+ let escadrille: JSONNull?
2189+ let estrous: JSONNull?
2190+ let interestedly: JSONNull?
2191+ let katakinetomer: JSONNull?
2192+ let mortification: JSONNull?
2193+ let morula: JSONNull?
2194+ let orthosymmetrical: JSONNull?
2195+ let overbark: JSONNull?
2196+ let politist: JSONNull?
2197+ let qualified: JSONNull?
2198+ let sphenomalar: JSONNull?
2199+ let throatful: JSONNull?
2200+ let transhumance: JSONNull?
2201+ let triandrian: JSONNull?
2202+ let unbooked: JSONNull?
2203+
2204+ enum CodingKeys: String, CodingKey {
2205+ case aeschynanthus = "Aeschynanthus"
2206+ case aquiferous = "aquiferous"
2207+ case cheapener = "cheapener"
2208+ case enumeration = "enumeration"
2209+ case ephesine = "Ephesine"
2210+ case escadrille = "escadrille"
2211+ case estrous = "estrous"
2212+ case interestedly = "interestedly"
2213+ case katakinetomer = "katakinetomer"
2214+ case mortification = "mortification"
2215+ case morula = "morula"
2216+ case orthosymmetrical = "orthosymmetrical"
2217+ case overbark = "overbark"
2218+ case politist = "politist"
2219+ case qualified = "qualified"
2220+ case sphenomalar = "sphenomalar"
2221+ case throatful = "throatful"
2222+ case transhumance = "transhumance"
2223+ case triandrian = "triandrian"
2224+ case unbooked = "unbooked"
2225+ }
2226+ }
2227+}
2228+
2229+// MARK: TopLevel convenience initializers and mutators
2230+
2231+extension TopLevel {
2232+ init(data: Data) throws {
2233+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
2234+ }
2235+
2236+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2237+ guard let data = json.data(using: encoding) else {
2238+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2239+ }
2240+ try self.init(data: data)
2241+ }
2242+
2243+ init(fromURL url: URL) throws {
2244+ try self.init(data: try Data(contentsOf: url))
2245+ }
2246+
2247+ func with(
2248+ protrusive: [TopLevel.Protrusive]? = nil,
2249+ pulpitism: [TopLevel.PulpitismElement]? = nil,
2250+ pyodermia: [TopLevel.PyodermiaElement]? = nil,
2251+ quebrachine: [TopLevel.QuebrachineElement]? = nil,
2252+ querier: [TopLevel.Querier]? = nil,
2253+ rebarbative: [TopLevel.Rebarbative]? = nil,
2254+ reimagine: [TopLevel.Reimagine]? = nil,
2255+ ressaut: TopLevel.Ressaut? = nil,
2256+ retrocervical: [TopLevel.Retrocervical]? = nil,
2257+ revert: [TopLevel.Revert]? = nil,
2258+ rewrite: [TopLevel.RewriteElement]? = nil,
2259+ saccoderm: [TopLevel.Saccoderm]? = nil,
2260+ santir: [TopLevel.SantirElement]? = nil,
2261+ saprophilous: [TopLevel.Saprophilous]? = nil,
2262+ saxten: [TopLevel.SaxtenElement]? = nil,
2263+ scatty: [TopLevel.Scatty?]? = nil,
2264+ scoffer: [TopLevel.Scoffer]? = nil,
2265+ scrampum: [TopLevel.Scrampum]? = nil,
2266+ semantic: Double? = nil,
2267+ serpentinic: [TopLevel.Serpentinic]? = nil,
2268+ shadowable: [TopLevel.Shadowable]? = nil,
2269+ sistering: [TopLevel.SisteringElement]? = nil,
2270+ staghunting: [TopLevel.Staghunting]? = nil,
2271+ stagmometer: [TopLevel.Stagmometer]? = nil,
2272+ stimulability: [TopLevel.Stimulability]? = nil,
2273+ strangleable: [TopLevel.Strangleable]? = nil,
2274+ strenuosity: [TopLevel.StrenuosityElement]? = nil,
2275+ tabaxir: [TopLevel.Tabaxir]? = nil,
2276+ talpiform: [TopLevel.Talpiform]? = nil,
2277+ thwack: [TopLevel.Thwack]? = nil,
2278+ to: [Double?]? = nil,
2279+ tortricine: [TopLevel.Tortricine]? = nil,
2280+ truantcy: [TopLevel.TruantcyElement]? = nil,
2281+ turgesce: [String]? = nil,
2282+ unbeginning: [TopLevel.Unbeginning]? = nil,
2283+ underdunged: [Double]? = nil,
2284+ undesirability: [TopLevel.Undesirability]? = nil,
2285+ unerasing: [TopLevel.Unerasing]? = nil,
2286+ unguentarium: [TopLevel.Unguentarium]? = nil,
2287+ unimpeachably: [TopLevel.UnimpeachablyElement]? = nil,
2288+ unmortgaged: [TopLevel.Unmortgaged]? = nil,
2289+ unobstructed: [TopLevel.Unobstructed]? = nil,
2290+ unreceptivity: [TopLevel.Unreceptivity]? = nil,
2291+ unsatisfactoriness: [TopLevel.Unsatisfactoriness]? = nil,
2292+ unsecurity: [Int]? = nil,
2293+ unstressed: [TopLevel.UnstressedElement]? = nil,
2294+ untasked: [TopLevel.Untasked]? = nil,
2295+ unvarying: [TopLevel.Unvarying]? = nil,
2296+ vehemently: [TopLevel.Vehemently]? = nil,
2297+ warriorship: [String: Bool]? = nil,
2298+ whitepot: [TopLevel.Whitepot]? = nil,
2299+ wrothy: [TopLevel.WrothyElement]? = nil
2300+ ) -> TopLevel {
2301+ return TopLevel(
2302+ protrusive: protrusive ?? self.protrusive,
2303+ pulpitism: pulpitism ?? self.pulpitism,
2304+ pyodermia: pyodermia ?? self.pyodermia,
2305+ quebrachine: quebrachine ?? self.quebrachine,
2306+ querier: querier ?? self.querier,
2307+ rebarbative: rebarbative ?? self.rebarbative,
2308+ reimagine: reimagine ?? self.reimagine,
2309+ ressaut: ressaut ?? self.ressaut,
2310+ retrocervical: retrocervical ?? self.retrocervical,
2311+ revert: revert ?? self.revert,
2312+ rewrite: rewrite ?? self.rewrite,
2313+ saccoderm: saccoderm ?? self.saccoderm,
2314+ santir: santir ?? self.santir,
2315+ saprophilous: saprophilous ?? self.saprophilous,
2316+ saxten: saxten ?? self.saxten,
2317+ scatty: scatty ?? self.scatty,
2318+ scoffer: scoffer ?? self.scoffer,
2319+ scrampum: scrampum ?? self.scrampum,
2320+ semantic: semantic ?? self.semantic,
2321+ serpentinic: serpentinic ?? self.serpentinic,
2322+ shadowable: shadowable ?? self.shadowable,
2323+ sistering: sistering ?? self.sistering,
2324+ staghunting: staghunting ?? self.staghunting,
2325+ stagmometer: stagmometer ?? self.stagmometer,
2326+ stimulability: stimulability ?? self.stimulability,
2327+ strangleable: strangleable ?? self.strangleable,
2328+ strenuosity: strenuosity ?? self.strenuosity,
2329+ tabaxir: tabaxir ?? self.tabaxir,
2330+ talpiform: talpiform ?? self.talpiform,
2331+ thwack: thwack ?? self.thwack,
2332+ to: to ?? self.to,
2333+ tortricine: tortricine ?? self.tortricine,
2334+ truantcy: truantcy ?? self.truantcy,
2335+ turgesce: turgesce ?? self.turgesce,
2336+ unbeginning: unbeginning ?? self.unbeginning,
2337+ underdunged: underdunged ?? self.underdunged,
2338+ undesirability: undesirability ?? self.undesirability,
2339+ unerasing: unerasing ?? self.unerasing,
2340+ unguentarium: unguentarium ?? self.unguentarium,
2341+ unimpeachably: unimpeachably ?? self.unimpeachably,
2342+ unmortgaged: unmortgaged ?? self.unmortgaged,
2343+ unobstructed: unobstructed ?? self.unobstructed,
2344+ unreceptivity: unreceptivity ?? self.unreceptivity,
2345+ unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness,
2346+ unsecurity: unsecurity ?? self.unsecurity,
2347+ unstressed: unstressed ?? self.unstressed,
2348+ untasked: untasked ?? self.untasked,
2349+ unvarying: unvarying ?? self.unvarying,
2350+ vehemently: vehemently ?? self.vehemently,
2351+ warriorship: warriorship ?? self.warriorship,
2352+ whitepot: whitepot ?? self.whitepot,
2353+ wrothy: wrothy ?? self.wrothy
2354+ )
2355+ }
2356+
2357+ func jsonData() throws -> Data {
2358+ return try newJSONEncoder().encode(self)
2359+ }
2360+
2361+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2362+ return String(data: try self.jsonData(), encoding: encoding)
2363+ }
2364+}
2365+
2366+extension TopLevel.PulpitismClass {
2367+ init(data: Data) throws {
2368+ self = try newJSONDecoder().decode(TopLevel.PulpitismClass.self, from: data)
2369+ }
2370+
2371+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2372+ guard let data = json.data(using: encoding) else {
2373+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2374+ }
2375+ try self.init(data: data)
2376+ }
2377+
2378+ init(fromURL url: URL) throws {
2379+ try self.init(data: try Data(contentsOf: url))
2380+ }
2381+
2382+ func with(
2383+ abnet: JSONNull?? = nil,
2384+ buckhorn: JSONNull?? = nil,
2385+ calciform: JSONNull?? = nil,
2386+ chelophore: JSONNull?? = nil,
2387+ cogitation: JSONNull?? = nil,
2388+ decreeable: JSONNull?? = nil,
2389+ despicable: JSONNull?? = nil,
2390+ isodiazo: JSONNull?? = nil,
2391+ jadedly: JSONNull?? = nil,
2392+ leptochlorite: JSONNull?? = nil,
2393+ nursling: JSONNull?? = nil,
2394+ palamedean: JSONNull?? = nil,
2395+ photoheliograph: JSONNull?? = nil,
2396+ pipewood: JSONNull?? = nil,
2397+ roberd: JSONNull?? = nil,
2398+ statable: JSONNull?? = nil,
2399+ superassume: JSONNull?? = nil,
2400+ syllabe: JSONNull?? = nil,
2401+ toughhead: JSONNull?? = nil,
2402+ underburn: JSONNull?? = nil
2403+ ) -> TopLevel.PulpitismClass {
2404+ return TopLevel.PulpitismClass(
2405+ abnet: abnet ?? self.abnet,
2406+ buckhorn: buckhorn ?? self.buckhorn,
2407+ calciform: calciform ?? self.calciform,
2408+ chelophore: chelophore ?? self.chelophore,
2409+ cogitation: cogitation ?? self.cogitation,
2410+ decreeable: decreeable ?? self.decreeable,
2411+ despicable: despicable ?? self.despicable,
2412+ isodiazo: isodiazo ?? self.isodiazo,
2413+ jadedly: jadedly ?? self.jadedly,
2414+ leptochlorite: leptochlorite ?? self.leptochlorite,
2415+ nursling: nursling ?? self.nursling,
2416+ palamedean: palamedean ?? self.palamedean,
2417+ photoheliograph: photoheliograph ?? self.photoheliograph,
2418+ pipewood: pipewood ?? self.pipewood,
2419+ roberd: roberd ?? self.roberd,
2420+ statable: statable ?? self.statable,
2421+ superassume: superassume ?? self.superassume,
2422+ syllabe: syllabe ?? self.syllabe,
2423+ toughhead: toughhead ?? self.toughhead,
2424+ underburn: underburn ?? self.underburn
2425+ )
2426+ }
2427+
2428+ func jsonData() throws -> Data {
2429+ return try newJSONEncoder().encode(self)
2430+ }
2431+
2432+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2433+ return String(data: try self.jsonData(), encoding: encoding)
2434+ }
2435+}
2436+
2437+extension TopLevel.PyodermiaClass {
2438+ init(data: Data) throws {
2439+ self = try newJSONDecoder().decode(TopLevel.PyodermiaClass.self, from: data)
2440+ }
2441+
2442+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2443+ guard let data = json.data(using: encoding) else {
2444+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2445+ }
2446+ try self.init(data: data)
2447+ }
2448+
2449+ init(fromURL url: URL) throws {
2450+ try self.init(data: try Data(contentsOf: url))
2451+ }
2452+
2453+ func with(
2454+ aphoristically: JSONNull?? = nil,
2455+ apophyllous: JSONNull?? = nil,
2456+ cognize: JSONNull?? = nil,
2457+ dermonosology: JSONNull?? = nil,
2458+ gyppo: JSONNull?? = nil,
2459+ ither: JSONNull?? = nil,
2460+ juglandaceous: JSONNull?? = nil,
2461+ litho: JSONNull?? = nil,
2462+ macropterous: JSONNull?? = nil,
2463+ photographer: JSONNull?? = nil,
2464+ romancing: JSONNull?? = nil,
2465+ rumness: JSONNull?? = nil,
2466+ somniloquist: JSONNull?? = nil,
2467+ stressfully: JSONNull?? = nil,
2468+ tactically: JSONNull?? = nil,
2469+ tracheophony: JSONNull?? = nil,
2470+ unappositely: JSONNull?? = nil,
2471+ unclothedly: JSONNull?? = nil,
2472+ unimplied: JSONNull?? = nil,
2473+ unsyncopated: JSONNull?? = nil
2474+ ) -> TopLevel.PyodermiaClass {
2475+ return TopLevel.PyodermiaClass(
2476+ aphoristically: aphoristically ?? self.aphoristically,
2477+ apophyllous: apophyllous ?? self.apophyllous,
2478+ cognize: cognize ?? self.cognize,
2479+ dermonosology: dermonosology ?? self.dermonosology,
2480+ gyppo: gyppo ?? self.gyppo,
2481+ ither: ither ?? self.ither,
2482+ juglandaceous: juglandaceous ?? self.juglandaceous,
2483+ litho: litho ?? self.litho,
2484+ macropterous: macropterous ?? self.macropterous,
2485+ photographer: photographer ?? self.photographer,
2486+ romancing: romancing ?? self.romancing,
2487+ rumness: rumness ?? self.rumness,
2488+ somniloquist: somniloquist ?? self.somniloquist,
2489+ stressfully: stressfully ?? self.stressfully,
2490+ tactically: tactically ?? self.tactically,
2491+ tracheophony: tracheophony ?? self.tracheophony,
2492+ unappositely: unappositely ?? self.unappositely,
2493+ unclothedly: unclothedly ?? self.unclothedly,
2494+ unimplied: unimplied ?? self.unimplied,
2495+ unsyncopated: unsyncopated ?? self.unsyncopated
2496+ )
2497+ }
2498+
2499+ func jsonData() throws -> Data {
2500+ return try newJSONEncoder().encode(self)
2501+ }
2502+
2503+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2504+ return String(data: try self.jsonData(), encoding: encoding)
2505+ }
2506+}
2507+
2508+extension TopLevel.QuebrachineClass {
2509+ init(data: Data) throws {
2510+ self = try newJSONDecoder().decode(TopLevel.QuebrachineClass.self, from: data)
2511+ }
2512+
2513+ 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+ init(fromURL url: URL) throws {
2521+ try self.init(data: try Data(contentsOf: url))
2522+ }
2523+
2524+ func with(
2525+ catharticalness: Double? = nil,
2526+ chirotherium: Int? = nil,
2527+ disdiapason: String? = nil,
2528+ homocerc: Bool? = nil,
2529+ nonbookish: JSONNull?? = nil
2530+ ) -> TopLevel.QuebrachineClass {
2531+ return TopLevel.QuebrachineClass(
2532+ catharticalness: catharticalness ?? self.catharticalness,
2533+ chirotherium: chirotherium ?? self.chirotherium,
2534+ disdiapason: disdiapason ?? self.disdiapason,
2535+ homocerc: homocerc ?? self.homocerc,
2536+ nonbookish: nonbookish ?? self.nonbookish
2537+ )
2538+ }
2539+
2540+ func jsonData() throws -> Data {
2541+ return try newJSONEncoder().encode(self)
2542+ }
2543+
2544+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2545+ return String(data: try self.jsonData(), encoding: encoding)
2546+ }
2547+}
2548+
2549+extension TopLevel.Reimagine {
2550+ init(data: Data) throws {
2551+ self = try newJSONDecoder().decode(TopLevel.Reimagine.self, from: data)
2552+ }
2553+
2554+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2555+ guard let data = json.data(using: encoding) else {
2556+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2557+ }
2558+ try self.init(data: data)
2559+ }
2560+
2561+ init(fromURL url: URL) throws {
2562+ try self.init(data: try Data(contentsOf: url))
2563+ }
2564+
2565+ func with(
2566+ adducible: JSONNull?? = nil,
2567+ anabolin: JSONNull?? = nil,
2568+ brainy: JSONNull?? = nil,
2569+ catharticalness: Double?? = nil,
2570+ chirotherium: Int?? = nil,
2571+ chrysamine: JSONNull?? = nil,
2572+ disdiapason: String?? = nil,
2573+ fluxweed: JSONNull?? = nil,
2574+ glaucine: JSONNull?? = nil,
2575+ grobianism: JSONNull?? = nil,
2576+ hermo: JSONNull?? = nil,
2577+ hieroglyphist: JSONNull?? = nil,
2578+ homocerc: Bool?? = nil,
2579+ icteroid: JSONNull?? = nil,
2580+ immortal: JSONNull?? = nil,
2581+ impetulant: JSONNull?? = nil,
2582+ irrigate: JSONNull?? = nil,
2583+ myxedema: JSONNull?? = nil,
2584+ nonbookish: JSONNull?? = nil,
2585+ onyx: JSONNull?? = nil,
2586+ repasser: JSONNull?? = nil,
2587+ septomarginal: JSONNull?? = nil,
2588+ subdie: JSONNull?? = nil,
2589+ tibiometatarsal: JSONNull?? = nil,
2590+ waltzlike: JSONNull?? = nil
2591+ ) -> TopLevel.Reimagine {
2592+ return TopLevel.Reimagine(
2593+ adducible: adducible ?? self.adducible,
2594+ anabolin: anabolin ?? self.anabolin,
2595+ brainy: brainy ?? self.brainy,
2596+ catharticalness: catharticalness ?? self.catharticalness,
2597+ chirotherium: chirotherium ?? self.chirotherium,
2598+ chrysamine: chrysamine ?? self.chrysamine,
2599+ disdiapason: disdiapason ?? self.disdiapason,
2600+ fluxweed: fluxweed ?? self.fluxweed,
2601+ glaucine: glaucine ?? self.glaucine,
2602+ grobianism: grobianism ?? self.grobianism,
2603+ hermo: hermo ?? self.hermo,
2604+ hieroglyphist: hieroglyphist ?? self.hieroglyphist,
2605+ homocerc: homocerc ?? self.homocerc,
2606+ icteroid: icteroid ?? self.icteroid,
2607+ immortal: immortal ?? self.immortal,
2608+ impetulant: impetulant ?? self.impetulant,
2609+ irrigate: irrigate ?? self.irrigate,
2610+ myxedema: myxedema ?? self.myxedema,
2611+ nonbookish: nonbookish ?? self.nonbookish,
2612+ onyx: onyx ?? self.onyx,
2613+ repasser: repasser ?? self.repasser,
2614+ septomarginal: septomarginal ?? self.septomarginal,
2615+ subdie: subdie ?? self.subdie,
2616+ tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal,
2617+ waltzlike: waltzlike ?? self.waltzlike
2618+ )
2619+ }
2620+
2621+ func jsonData() throws -> Data {
2622+ return try newJSONEncoder().encode(self)
2623+ }
2624+
2625+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2626+ return String(data: try self.jsonData(), encoding: encoding)
2627+ }
2628+}
2629+
2630+extension TopLevel.Ressaut {
2631+ init(data: Data) throws {
2632+ self = try newJSONDecoder().decode(TopLevel.Ressaut.self, from: data)
2633+ }
2634+
2635+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2636+ guard let data = json.data(using: encoding) else {
2637+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2638+ }
2639+ try self.init(data: data)
2640+ }
2641+
2642+ init(fromURL url: URL) throws {
2643+ try self.init(data: try Data(contentsOf: url))
2644+ }
2645+
2646+ func with(
2647+ apperceptive: String? = nil,
2648+ cuttoo: String? = nil,
2649+ douser: String? = nil,
2650+ drinkproof: String? = nil,
2651+ forementioned: String? = nil,
2652+ freesia: String? = nil,
2653+ genevieve: String? = nil,
2654+ hyperdiabolical: String? = nil,
2655+ hypocone: String? = nil,
2656+ irreverentially: String? = nil,
2657+ jumart: String? = nil,
2658+ mimosaceae: String? = nil,
2659+ mollicrush: String? = nil,
2660+ nedder: String? = nil,
2661+ retinasphalt: String? = nil,
2662+ sough: String? = nil,
2663+ steading: String? = nil,
2664+ theopaschitism: String? = nil,
2665+ undurableness: String? = nil,
2666+ unmingleable: String? = nil
2667+ ) -> TopLevel.Ressaut {
2668+ return TopLevel.Ressaut(
2669+ apperceptive: apperceptive ?? self.apperceptive,
2670+ cuttoo: cuttoo ?? self.cuttoo,
2671+ douser: douser ?? self.douser,
2672+ drinkproof: drinkproof ?? self.drinkproof,
2673+ forementioned: forementioned ?? self.forementioned,
2674+ freesia: freesia ?? self.freesia,
2675+ genevieve: genevieve ?? self.genevieve,
2676+ hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical,
2677+ hypocone: hypocone ?? self.hypocone,
2678+ irreverentially: irreverentially ?? self.irreverentially,
2679+ jumart: jumart ?? self.jumart,
2680+ mimosaceae: mimosaceae ?? self.mimosaceae,
2681+ mollicrush: mollicrush ?? self.mollicrush,
2682+ nedder: nedder ?? self.nedder,
2683+ retinasphalt: retinasphalt ?? self.retinasphalt,
2684+ sough: sough ?? self.sough,
2685+ steading: steading ?? self.steading,
2686+ theopaschitism: theopaschitism ?? self.theopaschitism,
2687+ undurableness: undurableness ?? self.undurableness,
2688+ unmingleable: unmingleable ?? self.unmingleable
2689+ )
2690+ }
2691+
2692+ func jsonData() throws -> Data {
2693+ return try newJSONEncoder().encode(self)
2694+ }
2695+
2696+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2697+ return String(data: try self.jsonData(), encoding: encoding)
2698+ }
2699+}
2700+
2701+extension TopLevel.RewriteClass {
2702+ init(data: Data) throws {
2703+ self = try newJSONDecoder().decode(TopLevel.RewriteClass.self, from: data)
2704+ }
2705+
2706+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2707+ guard let data = json.data(using: encoding) else {
2708+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2709+ }
2710+ try self.init(data: data)
2711+ }
2712+
2713+ init(fromURL url: URL) throws {
2714+ try self.init(data: try Data(contentsOf: url))
2715+ }
2716+
2717+ func with(
2718+ accountancy: JSONNull?? = nil,
2719+ cacotrophic: JSONNull?? = nil,
2720+ contest: JSONNull?? = nil,
2721+ couthily: JSONNull?? = nil,
2722+ falculate: JSONNull?? = nil,
2723+ foreseize: JSONNull?? = nil,
2724+ hyades: JSONNull?? = nil,
2725+ lemnad: JSONNull?? = nil,
2726+ monotheistically: JSONNull?? = nil,
2727+ nonflying: JSONNull?? = nil,
2728+ ptenoglossa: JSONNull?? = nil,
2729+ repatch: JSONNull?? = nil,
2730+ rodman: JSONNull?? = nil,
2731+ strung: JSONNull?? = nil,
2732+ titmal: JSONNull?? = nil,
2733+ twalpennyworth: JSONNull?? = nil,
2734+ unblamable: JSONNull?? = nil,
2735+ vertical: JSONNull?? = nil,
2736+ whiggification: JSONNull?? = nil,
2737+ yardman: JSONNull?? = nil
2738+ ) -> TopLevel.RewriteClass {
2739+ return TopLevel.RewriteClass(
2740+ accountancy: accountancy ?? self.accountancy,
2741+ cacotrophic: cacotrophic ?? self.cacotrophic,
2742+ contest: contest ?? self.contest,
2743+ couthily: couthily ?? self.couthily,
2744+ falculate: falculate ?? self.falculate,
2745+ foreseize: foreseize ?? self.foreseize,
2746+ hyades: hyades ?? self.hyades,
2747+ lemnad: lemnad ?? self.lemnad,
2748+ monotheistically: monotheistically ?? self.monotheistically,
2749+ nonflying: nonflying ?? self.nonflying,
2750+ ptenoglossa: ptenoglossa ?? self.ptenoglossa,
2751+ repatch: repatch ?? self.repatch,
2752+ rodman: rodman ?? self.rodman,
2753+ strung: strung ?? self.strung,
2754+ titmal: titmal ?? self.titmal,
2755+ twalpennyworth: twalpennyworth ?? self.twalpennyworth,
2756+ unblamable: unblamable ?? self.unblamable,
2757+ vertical: vertical ?? self.vertical,
2758+ whiggification: whiggification ?? self.whiggification,
2759+ yardman: yardman ?? self.yardman
2760+ )
2761+ }
2762+
2763+ func jsonData() throws -> Data {
2764+ return try newJSONEncoder().encode(self)
2765+ }
2766+
2767+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2768+ return String(data: try self.jsonData(), encoding: encoding)
2769+ }
2770+}
2771+
2772+extension TopLevel.SantirClass {
2773+ init(data: Data) throws {
2774+ self = try newJSONDecoder().decode(TopLevel.SantirClass.self, from: data)
2775+ }
2776+
2777+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2778+ guard let data = json.data(using: encoding) else {
2779+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2780+ }
2781+ try self.init(data: data)
2782+ }
2783+
2784+ init(fromURL url: URL) throws {
2785+ try self.init(data: try Data(contentsOf: url))
2786+ }
2787+
2788+ func with(
2789+ admiredly: JSONNull?? = nil,
2790+ demicaponier: JSONNull?? = nil,
2791+ epitympanic: JSONNull?? = nil,
2792+ investitor: JSONNull?? = nil,
2793+ lupiform: JSONNull?? = nil,
2794+ monoflagellate: JSONNull?? = nil,
2795+ paleoethnic: JSONNull?? = nil,
2796+ prediscountable: JSONNull?? = nil,
2797+ rhetoricals: JSONNull?? = nil,
2798+ roomth: JSONNull?? = nil,
2799+ saccharose: JSONNull?? = nil,
2800+ septonasal: JSONNull?? = nil,
2801+ serpenticide: JSONNull?? = nil,
2802+ setarious: JSONNull?? = nil,
2803+ spaework: JSONNull?? = nil,
2804+ stylite: JSONNull?? = nil,
2805+ suessiones: JSONNull?? = nil,
2806+ timelily: JSONNull?? = nil,
2807+ unprofaned: JSONNull?? = nil,
2808+ vorticular: JSONNull?? = nil
2809+ ) -> TopLevel.SantirClass {
2810+ return TopLevel.SantirClass(
2811+ admiredly: admiredly ?? self.admiredly,
2812+ demicaponier: demicaponier ?? self.demicaponier,
2813+ epitympanic: epitympanic ?? self.epitympanic,
2814+ investitor: investitor ?? self.investitor,
2815+ lupiform: lupiform ?? self.lupiform,
2816+ monoflagellate: monoflagellate ?? self.monoflagellate,
2817+ paleoethnic: paleoethnic ?? self.paleoethnic,
2818+ prediscountable: prediscountable ?? self.prediscountable,
2819+ rhetoricals: rhetoricals ?? self.rhetoricals,
2820+ roomth: roomth ?? self.roomth,
2821+ saccharose: saccharose ?? self.saccharose,
2822+ septonasal: septonasal ?? self.septonasal,
2823+ serpenticide: serpenticide ?? self.serpenticide,
2824+ setarious: setarious ?? self.setarious,
2825+ spaework: spaework ?? self.spaework,
2826+ stylite: stylite ?? self.stylite,
2827+ suessiones: suessiones ?? self.suessiones,
2828+ timelily: timelily ?? self.timelily,
2829+ unprofaned: unprofaned ?? self.unprofaned,
2830+ vorticular: vorticular ?? self.vorticular
2831+ )
2832+ }
2833+
2834+ func jsonData() throws -> Data {
2835+ return try newJSONEncoder().encode(self)
2836+ }
2837+
2838+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2839+ return String(data: try self.jsonData(), encoding: encoding)
2840+ }
2841+}
2842+
2843+extension TopLevel.SaxtenClass {
2844+ init(data: Data) throws {
2845+ self = try newJSONDecoder().decode(TopLevel.SaxtenClass.self, from: data)
2846+ }
2847+
2848+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2849+ guard let data = json.data(using: encoding) else {
2850+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2851+ }
2852+ try self.init(data: data)
2853+ }
2854+
2855+ init(fromURL url: URL) throws {
2856+ try self.init(data: try Data(contentsOf: url))
2857+ }
2858+
2859+ func with(
2860+ algarrobilla: JSONNull?? = nil,
2861+ bowgrace: JSONNull?? = nil,
2862+ catharticalness: Double?? = nil,
2863+ centaurid: JSONNull?? = nil,
2864+ chirotherium: Int?? = nil,
2865+ disdiapason: String?? = nil,
2866+ flix: JSONNull?? = nil,
2867+ germanely: JSONNull?? = nil,
2868+ homocerc: Bool?? = nil,
2869+ inhume: JSONNull?? = nil,
2870+ lepidote: JSONNull?? = nil,
2871+ megalochirous: JSONNull?? = nil,
2872+ ninepenny: JSONNull?? = nil,
2873+ nonbookish: JSONNull?? = nil,
2874+ nondeist: JSONNull?? = nil,
2875+ nymphaeaceous: JSONNull?? = nil,
2876+ parietofrontal: JSONNull?? = nil,
2877+ sancyite: JSONNull?? = nil,
2878+ subjectivist: JSONNull?? = nil,
2879+ tibiad: JSONNull?? = nil,
2880+ transonic: JSONNull?? = nil,
2881+ tripetalous: JSONNull?? = nil,
2882+ trunchman: JSONNull?? = nil,
2883+ urger: JSONNull?? = nil,
2884+ withdrawnness: JSONNull?? = nil
2885+ ) -> TopLevel.SaxtenClass {
2886+ return TopLevel.SaxtenClass(
2887+ algarrobilla: algarrobilla ?? self.algarrobilla,
2888+ bowgrace: bowgrace ?? self.bowgrace,
2889+ catharticalness: catharticalness ?? self.catharticalness,
2890+ centaurid: centaurid ?? self.centaurid,
2891+ chirotherium: chirotherium ?? self.chirotherium,
2892+ disdiapason: disdiapason ?? self.disdiapason,
2893+ flix: flix ?? self.flix,
2894+ germanely: germanely ?? self.germanely,
2895+ homocerc: homocerc ?? self.homocerc,
2896+ inhume: inhume ?? self.inhume,
2897+ lepidote: lepidote ?? self.lepidote,
2898+ megalochirous: megalochirous ?? self.megalochirous,
2899+ ninepenny: ninepenny ?? self.ninepenny,
2900+ nonbookish: nonbookish ?? self.nonbookish,
2901+ nondeist: nondeist ?? self.nondeist,
2902+ nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous,
2903+ parietofrontal: parietofrontal ?? self.parietofrontal,
2904+ sancyite: sancyite ?? self.sancyite,
2905+ subjectivist: subjectivist ?? self.subjectivist,
2906+ tibiad: tibiad ?? self.tibiad,
2907+ transonic: transonic ?? self.transonic,
2908+ tripetalous: tripetalous ?? self.tripetalous,
2909+ trunchman: trunchman ?? self.trunchman,
2910+ urger: urger ?? self.urger,
2911+ withdrawnness: withdrawnness ?? self.withdrawnness
2912+ )
2913+ }
2914+
2915+ func jsonData() throws -> Data {
2916+ return try newJSONEncoder().encode(self)
2917+ }
2918+
2919+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2920+ return String(data: try self.jsonData(), encoding: encoding)
2921+ }
2922+}
2923+
2924+extension TopLevel.Scatty {
2925+ init(data: Data) throws {
2926+ self = try newJSONDecoder().decode(TopLevel.Scatty.self, from: data)
2927+ }
2928+
2929+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2930+ guard let data = json.data(using: encoding) else {
2931+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2932+ }
2933+ try self.init(data: data)
2934+ }
2935+
2936+ init(fromURL url: URL) throws {
2937+ try self.init(data: try Data(contentsOf: url))
2938+ }
2939+
2940+ func with(
2941+ aeriferous: JSONNull?? = nil,
2942+ antical: JSONNull?? = nil,
2943+ antighostism: JSONNull?? = nil,
2944+ arcanum: JSONNull?? = nil,
2945+ autotrophy: JSONNull?? = nil,
2946+ baronial: JSONNull?? = nil,
2947+ caffeine: JSONNull?? = nil,
2948+ gorgoniacean: JSONNull?? = nil,
2949+ heroical: JSONNull?? = nil,
2950+ hydropical: JSONNull?? = nil,
2951+ mechanology: JSONNull?? = nil,
2952+ musicopoetic: JSONNull?? = nil,
2953+ officiality: JSONNull?? = nil,
2954+ oftentimes: JSONNull?? = nil,
2955+ ophthalmotonometer: JSONNull?? = nil,
2956+ reflectively: JSONNull?? = nil,
2957+ springer: JSONNull?? = nil,
2958+ tabasco: JSONNull?? = nil,
2959+ teleianthous: JSONNull?? = nil,
2960+ uncombated: JSONNull?? = nil
2961+ ) -> TopLevel.Scatty {
2962+ return TopLevel.Scatty(
2963+ aeriferous: aeriferous ?? self.aeriferous,
2964+ antical: antical ?? self.antical,
2965+ antighostism: antighostism ?? self.antighostism,
2966+ arcanum: arcanum ?? self.arcanum,
2967+ autotrophy: autotrophy ?? self.autotrophy,
2968+ baronial: baronial ?? self.baronial,
2969+ caffeine: caffeine ?? self.caffeine,
2970+ gorgoniacean: gorgoniacean ?? self.gorgoniacean,
2971+ heroical: heroical ?? self.heroical,
2972+ hydropical: hydropical ?? self.hydropical,
2973+ mechanology: mechanology ?? self.mechanology,
2974+ musicopoetic: musicopoetic ?? self.musicopoetic,
2975+ officiality: officiality ?? self.officiality,
2976+ oftentimes: oftentimes ?? self.oftentimes,
2977+ ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer,
2978+ reflectively: reflectively ?? self.reflectively,
2979+ springer: springer ?? self.springer,
2980+ tabasco: tabasco ?? self.tabasco,
2981+ teleianthous: teleianthous ?? self.teleianthous,
2982+ uncombated: uncombated ?? self.uncombated
2983+ )
2984+ }
2985+
2986+ func jsonData() throws -> Data {
2987+ return try newJSONEncoder().encode(self)
2988+ }
2989+
2990+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2991+ return String(data: try self.jsonData(), encoding: encoding)
2992+ }
2993+}
2994+
2995+extension TopLevel.SisteringClass {
2996+ init(data: Data) throws {
2997+ self = try newJSONDecoder().decode(TopLevel.SisteringClass.self, from: data)
2998+ }
2999+
3000+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3001+ guard let data = json.data(using: encoding) else {
3002+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3003+ }
3004+ try self.init(data: data)
3005+ }
3006+
3007+ init(fromURL url: URL) throws {
3008+ try self.init(data: try Data(contentsOf: url))
3009+ }
3010+
3011+ func with(
3012+ amphicarpic: JSONNull?? = nil,
3013+ chianti: JSONNull?? = nil,
3014+ frigorific: JSONNull?? = nil,
3015+ haplomi: JSONNull?? = nil,
3016+ hyperkinesis: JSONNull?? = nil,
3017+ laudable: JSONNull?? = nil,
3018+ madwoman: JSONNull?? = nil,
3019+ maimedly: JSONNull?? = nil,
3020+ micropterygidae: JSONNull?? = nil,
3021+ microrhabdus: JSONNull?? = nil,
3022+ nondense: JSONNull?? = nil,
3023+ phlebemphraxis: JSONNull?? = nil,
3024+ redsear: JSONNull?? = nil,
3025+ schismatical: JSONNull?? = nil,
3026+ tartryl: JSONNull?? = nil,
3027+ unabhorred: JSONNull?? = nil,
3028+ undeliberateness: JSONNull?? = nil,
3029+ unmixable: JSONNull?? = nil,
3030+ untruckling: JSONNull?? = nil,
3031+ vineal: JSONNull?? = nil
3032+ ) -> TopLevel.SisteringClass {
3033+ return TopLevel.SisteringClass(
3034+ amphicarpic: amphicarpic ?? self.amphicarpic,
3035+ chianti: chianti ?? self.chianti,
3036+ frigorific: frigorific ?? self.frigorific,
3037+ haplomi: haplomi ?? self.haplomi,
3038+ hyperkinesis: hyperkinesis ?? self.hyperkinesis,
3039+ laudable: laudable ?? self.laudable,
3040+ madwoman: madwoman ?? self.madwoman,
3041+ maimedly: maimedly ?? self.maimedly,
3042+ micropterygidae: micropterygidae ?? self.micropterygidae,
3043+ microrhabdus: microrhabdus ?? self.microrhabdus,
3044+ nondense: nondense ?? self.nondense,
3045+ phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis,
3046+ redsear: redsear ?? self.redsear,
3047+ schismatical: schismatical ?? self.schismatical,
3048+ tartryl: tartryl ?? self.tartryl,
3049+ unabhorred: unabhorred ?? self.unabhorred,
3050+ undeliberateness: undeliberateness ?? self.undeliberateness,
3051+ unmixable: unmixable ?? self.unmixable,
3052+ untruckling: untruckling ?? self.untruckling,
3053+ vineal: vineal ?? self.vineal
3054+ )
3055+ }
3056+
3057+ func jsonData() throws -> Data {
3058+ return try newJSONEncoder().encode(self)
3059+ }
3060+
3061+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3062+ return String(data: try self.jsonData(), encoding: encoding)
3063+ }
3064+}
3065+
3066+extension TopLevel.Staghunting {
3067+ init(data: Data) throws {
3068+ self = try newJSONDecoder().decode(TopLevel.Staghunting.self, from: data)
3069+ }
3070+
3071+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3072+ guard let data = json.data(using: encoding) else {
3073+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3074+ }
3075+ try self.init(data: data)
3076+ }
3077+
3078+ init(fromURL url: URL) throws {
3079+ try self.init(data: try Data(contentsOf: url))
3080+ }
3081+
3082+ func with(
3083+ calorimetric: Int?? = nil,
3084+ canid: Int?? = nil,
3085+ catharticalness: Double?? = nil,
3086+ chirotherium: Int?? = nil,
3087+ disdiapason: String?? = nil,
3088+ ditriglyphic: Int?? = nil,
3089+ floriferousness: Int?? = nil,
3090+ gamelike: Int?? = nil,
3091+ grig: Int?? = nil,
3092+ homocerc: Bool?? = nil,
3093+ interloan: Int?? = nil,
3094+ lithotomy: Int?? = nil,
3095+ loric: Int?? = nil,
3096+ membranocoriaceous: Int?? = nil,
3097+ membranogenic: Int?? = nil,
3098+ nonbookish: JSONNull?? = nil,
3099+ overtrump: Int?? = nil,
3100+ scotino: Int?? = nil,
3101+ seasonable: Int?? = nil,
3102+ sephen: Int?? = nil,
3103+ stigmarioid: Int?? = nil,
3104+ tired: Int?? = nil,
3105+ trifid: Int?? = nil,
3106+ undefeatedly: Int?? = nil,
3107+ ungirlish: Int?? = nil
3108+ ) -> TopLevel.Staghunting {
3109+ return TopLevel.Staghunting(
3110+ calorimetric: calorimetric ?? self.calorimetric,
3111+ canid: canid ?? self.canid,
3112+ catharticalness: catharticalness ?? self.catharticalness,
3113+ chirotherium: chirotherium ?? self.chirotherium,
3114+ disdiapason: disdiapason ?? self.disdiapason,
3115+ ditriglyphic: ditriglyphic ?? self.ditriglyphic,
3116+ floriferousness: floriferousness ?? self.floriferousness,
3117+ gamelike: gamelike ?? self.gamelike,
3118+ grig: grig ?? self.grig,
3119+ homocerc: homocerc ?? self.homocerc,
3120+ interloan: interloan ?? self.interloan,
3121+ lithotomy: lithotomy ?? self.lithotomy,
3122+ loric: loric ?? self.loric,
3123+ membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous,
3124+ membranogenic: membranogenic ?? self.membranogenic,
3125+ nonbookish: nonbookish ?? self.nonbookish,
3126+ overtrump: overtrump ?? self.overtrump,
3127+ scotino: scotino ?? self.scotino,
3128+ seasonable: seasonable ?? self.seasonable,
3129+ sephen: sephen ?? self.sephen,
3130+ stigmarioid: stigmarioid ?? self.stigmarioid,
3131+ tired: tired ?? self.tired,
3132+ trifid: trifid ?? self.trifid,
3133+ undefeatedly: undefeatedly ?? self.undefeatedly,
3134+ ungirlish: ungirlish ?? self.ungirlish
3135+ )
3136+ }
3137+
3138+ func jsonData() throws -> Data {
3139+ return try newJSONEncoder().encode(self)
3140+ }
3141+
3142+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3143+ return String(data: try self.jsonData(), encoding: encoding)
3144+ }
3145+}
3146+
3147+extension TopLevel.StrenuosityClass {
3148+ init(data: Data) throws {
3149+ self = try newJSONDecoder().decode(TopLevel.StrenuosityClass.self, from: data)
3150+ }
3151+
3152+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3153+ guard let data = json.data(using: encoding) else {
3154+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3155+ }
3156+ try self.init(data: data)
3157+ }
3158+
3159+ init(fromURL url: URL) throws {
3160+ try self.init(data: try Data(contentsOf: url))
3161+ }
3162+
3163+ func with(
3164+ bliss: Int?? = nil,
3165+ buccate: Int?? = nil,
3166+ bulletproof: Int?? = nil,
3167+ catharticalness: Double?? = nil,
3168+ chirotherium: Int?? = nil,
3169+ crumblingness: Int?? = nil,
3170+ disdiapason: String?? = nil,
3171+ engagedly: Int?? = nil,
3172+ fightable: Int?? = nil,
3173+ hoariness: Int?? = nil,
3174+ homocerc: Bool?? = nil,
3175+ hypopodium: Int?? = nil,
3176+ luxurist: Int?? = nil,
3177+ mechanician: Int?? = nil,
3178+ nonbookish: JSONNull?? = nil,
3179+ onopordon: Int?? = nil,
3180+ podgily: Int?? = nil,
3181+ reformableness: Int?? = nil,
3182+ scatterbrains: Int?? = nil,
3183+ seminuria: Int?? = nil,
3184+ sodomite: Int?? = nil,
3185+ tramp: Int?? = nil,
3186+ undueness: Int?? = nil,
3187+ worthily: Int?? = nil,
3188+ yankeeist: Int?? = nil
3189+ ) -> TopLevel.StrenuosityClass {
3190+ return TopLevel.StrenuosityClass(
3191+ bliss: bliss ?? self.bliss,
3192+ buccate: buccate ?? self.buccate,
3193+ bulletproof: bulletproof ?? self.bulletproof,
3194+ catharticalness: catharticalness ?? self.catharticalness,
3195+ chirotherium: chirotherium ?? self.chirotherium,
3196+ crumblingness: crumblingness ?? self.crumblingness,
3197+ disdiapason: disdiapason ?? self.disdiapason,
3198+ engagedly: engagedly ?? self.engagedly,
3199+ fightable: fightable ?? self.fightable,
3200+ hoariness: hoariness ?? self.hoariness,
3201+ homocerc: homocerc ?? self.homocerc,
3202+ hypopodium: hypopodium ?? self.hypopodium,
3203+ luxurist: luxurist ?? self.luxurist,
3204+ mechanician: mechanician ?? self.mechanician,
3205+ nonbookish: nonbookish ?? self.nonbookish,
3206+ onopordon: onopordon ?? self.onopordon,
3207+ podgily: podgily ?? self.podgily,
3208+ reformableness: reformableness ?? self.reformableness,
3209+ scatterbrains: scatterbrains ?? self.scatterbrains,
3210+ seminuria: seminuria ?? self.seminuria,
3211+ sodomite: sodomite ?? self.sodomite,
3212+ tramp: tramp ?? self.tramp,
3213+ undueness: undueness ?? self.undueness,
3214+ worthily: worthily ?? self.worthily,
3215+ yankeeist: yankeeist ?? self.yankeeist
3216+ )
3217+ }
3218+
3219+ func jsonData() throws -> Data {
3220+ return try newJSONEncoder().encode(self)
3221+ }
3222+
3223+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3224+ return String(data: try self.jsonData(), encoding: encoding)
3225+ }
3226+}
3227+
3228+extension TopLevel.TruantcyClass {
3229+ init(data: Data) throws {
3230+ self = try newJSONDecoder().decode(TopLevel.TruantcyClass.self, from: data)
3231+ }
3232+
3233+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3234+ guard let data = json.data(using: encoding) else {
3235+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3236+ }
3237+ try self.init(data: data)
3238+ }
3239+
3240+ init(fromURL url: URL) throws {
3241+ try self.init(data: try Data(contentsOf: url))
3242+ }
3243+
3244+ func with(
3245+ alfiona: JSONNull?? = nil,
3246+ ascaridiasis: JSONNull?? = nil,
3247+ bungey: JSONNull?? = nil,
3248+ catharticalness: Double?? = nil,
3249+ ceroxyle: JSONNull?? = nil,
3250+ chirotherium: Int?? = nil,
3251+ chorology: JSONNull?? = nil,
3252+ disdiapason: String?? = nil,
3253+ enmarble: JSONNull?? = nil,
3254+ epeira: JSONNull?? = nil,
3255+ eurylaimi: JSONNull?? = nil,
3256+ germination: JSONNull?? = nil,
3257+ hallelujah: JSONNull?? = nil,
3258+ homocerc: Bool?? = nil,
3259+ lev: JSONNull?? = nil,
3260+ mouthing: JSONNull?? = nil,
3261+ nonbookish: JSONNull?? = nil,
3262+ philliloo: JSONNull?? = nil,
3263+ planetal: JSONNull?? = nil,
3264+ poney: JSONNull?? = nil,
3265+ punctualist: JSONNull?? = nil,
3266+ returnlessly: JSONNull?? = nil,
3267+ skelder: JSONNull?? = nil,
3268+ windwaywardly: JSONNull?? = nil,
3269+ yuman: JSONNull?? = nil
3270+ ) -> TopLevel.TruantcyClass {
3271+ return TopLevel.TruantcyClass(
3272+ alfiona: alfiona ?? self.alfiona,
3273+ ascaridiasis: ascaridiasis ?? self.ascaridiasis,
3274+ bungey: bungey ?? self.bungey,
3275+ catharticalness: catharticalness ?? self.catharticalness,
3276+ ceroxyle: ceroxyle ?? self.ceroxyle,
3277+ chirotherium: chirotherium ?? self.chirotherium,
3278+ chorology: chorology ?? self.chorology,
3279+ disdiapason: disdiapason ?? self.disdiapason,
3280+ enmarble: enmarble ?? self.enmarble,
3281+ epeira: epeira ?? self.epeira,
3282+ eurylaimi: eurylaimi ?? self.eurylaimi,
3283+ germination: germination ?? self.germination,
3284+ hallelujah: hallelujah ?? self.hallelujah,
3285+ homocerc: homocerc ?? self.homocerc,
3286+ lev: lev ?? self.lev,
3287+ mouthing: mouthing ?? self.mouthing,
3288+ nonbookish: nonbookish ?? self.nonbookish,
3289+ philliloo: philliloo ?? self.philliloo,
3290+ planetal: planetal ?? self.planetal,
3291+ poney: poney ?? self.poney,
3292+ punctualist: punctualist ?? self.punctualist,
3293+ returnlessly: returnlessly ?? self.returnlessly,
3294+ skelder: skelder ?? self.skelder,
3295+ windwaywardly: windwaywardly ?? self.windwaywardly,
3296+ yuman: yuman ?? self.yuman
3297+ )
3298+ }
3299+
3300+ func jsonData() throws -> Data {
3301+ return try newJSONEncoder().encode(self)
3302+ }
3303+
3304+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3305+ return String(data: try self.jsonData(), encoding: encoding)
3306+ }
3307+}
3308+
3309+extension TopLevel.UnimpeachablyClass {
3310+ init(data: Data) throws {
3311+ self = try newJSONDecoder().decode(TopLevel.UnimpeachablyClass.self, from: data)
3312+ }
3313+
3314+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3315+ guard let data = json.data(using: encoding) else {
3316+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3317+ }
3318+ try self.init(data: data)
3319+ }
3320+
3321+ init(fromURL url: URL) throws {
3322+ try self.init(data: try Data(contentsOf: url))
3323+ }
3324+
3325+ func with(
3326+ acerin: Int?? = nil,
3327+ bobadil: Int?? = nil,
3328+ catharticalness: Double?? = nil,
3329+ chirotherium: Int?? = nil,
3330+ chlorophylligenous: Int?? = nil,
3331+ conversational: Int?? = nil,
3332+ demiowl: Int?? = nil,
3333+ disdiapason: String?? = nil,
3334+ ectorhinal: Int?? = nil,
3335+ gamblesomeness: Int?? = nil,
3336+ homocerc: Bool?? = nil,
3337+ irrorate: Int?? = nil,
3338+ kindergartening: Int?? = nil,
3339+ lateritic: Int?? = nil,
3340+ mespil: Int?? = nil,
3341+ misconfiguration: Int?? = nil,
3342+ nonbookish: JSONNull?? = nil,
3343+ planometry: Int?? = nil,
3344+ quiina: Int?? = nil,
3345+ robert: Int?? = nil,
3346+ rot: Int?? = nil,
3347+ subcinctorium: Int?? = nil,
3348+ tussocker: Int?? = nil,
3349+ ultraproud: Int?? = nil,
3350+ unsuggestedness: Int?? = nil
3351+ ) -> TopLevel.UnimpeachablyClass {
3352+ return TopLevel.UnimpeachablyClass(
3353+ acerin: acerin ?? self.acerin,
3354+ bobadil: bobadil ?? self.bobadil,
3355+ catharticalness: catharticalness ?? self.catharticalness,
3356+ chirotherium: chirotherium ?? self.chirotherium,
3357+ chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous,
3358+ conversational: conversational ?? self.conversational,
3359+ demiowl: demiowl ?? self.demiowl,
3360+ disdiapason: disdiapason ?? self.disdiapason,
3361+ ectorhinal: ectorhinal ?? self.ectorhinal,
3362+ gamblesomeness: gamblesomeness ?? self.gamblesomeness,
3363+ homocerc: homocerc ?? self.homocerc,
3364+ irrorate: irrorate ?? self.irrorate,
3365+ kindergartening: kindergartening ?? self.kindergartening,
3366+ lateritic: lateritic ?? self.lateritic,
3367+ mespil: mespil ?? self.mespil,
3368+ misconfiguration: misconfiguration ?? self.misconfiguration,
3369+ nonbookish: nonbookish ?? self.nonbookish,
3370+ planometry: planometry ?? self.planometry,
3371+ quiina: quiina ?? self.quiina,
3372+ robert: robert ?? self.robert,
3373+ rot: rot ?? self.rot,
3374+ subcinctorium: subcinctorium ?? self.subcinctorium,
3375+ tussocker: tussocker ?? self.tussocker,
3376+ ultraproud: ultraproud ?? self.ultraproud,
3377+ unsuggestedness: unsuggestedness ?? self.unsuggestedness
3378+ )
3379+ }
3380+
3381+ func jsonData() throws -> Data {
3382+ return try newJSONEncoder().encode(self)
3383+ }
3384+
3385+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3386+ return String(data: try self.jsonData(), encoding: encoding)
3387+ }
3388+}
3389+
3390+extension TopLevel.UnstressedClass {
3391+ init(data: Data) throws {
3392+ self = try newJSONDecoder().decode(TopLevel.UnstressedClass.self, from: data)
3393+ }
3394+
3395+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3396+ guard let data = json.data(using: encoding) else {
3397+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3398+ }
3399+ try self.init(data: data)
3400+ }
3401+
3402+ init(fromURL url: URL) throws {
3403+ try self.init(data: try Data(contentsOf: url))
3404+ }
3405+
3406+ func with(
3407+ alain: JSONNull?? = nil,
3408+ amphirhina: JSONNull?? = nil,
3409+ antimachinery: JSONNull?? = nil,
3410+ coldish: JSONNull?? = nil,
3411+ crantara: JSONNull?? = nil,
3412+ distinguishing: JSONNull?? = nil,
3413+ elytroposis: JSONNull?? = nil,
3414+ gentianwort: JSONNull?? = nil,
3415+ heliosis: JSONNull?? = nil,
3416+ instrumental: JSONNull?? = nil,
3417+ introinflection: JSONNull?? = nil,
3418+ kala: JSONNull?? = nil,
3419+ lincolnian: JSONNull?? = nil,
3420+ metad: JSONNull?? = nil,
3421+ sarcophilus: JSONNull?? = nil,
3422+ swingingly: JSONNull?? = nil,
3423+ unconformity: JSONNull?? = nil,
3424+ undecreed: JSONNull?? = nil,
3425+ venerable: JSONNull?? = nil,
3426+ vowellessness: JSONNull?? = nil
3427+ ) -> TopLevel.UnstressedClass {
3428+ return TopLevel.UnstressedClass(
3429+ alain: alain ?? self.alain,
3430+ amphirhina: amphirhina ?? self.amphirhina,
3431+ antimachinery: antimachinery ?? self.antimachinery,
3432+ coldish: coldish ?? self.coldish,
3433+ crantara: crantara ?? self.crantara,
3434+ distinguishing: distinguishing ?? self.distinguishing,
3435+ elytroposis: elytroposis ?? self.elytroposis,
3436+ gentianwort: gentianwort ?? self.gentianwort,
3437+ heliosis: heliosis ?? self.heliosis,
3438+ instrumental: instrumental ?? self.instrumental,
3439+ introinflection: introinflection ?? self.introinflection,
3440+ kala: kala ?? self.kala,
3441+ lincolnian: lincolnian ?? self.lincolnian,
3442+ metad: metad ?? self.metad,
3443+ sarcophilus: sarcophilus ?? self.sarcophilus,
3444+ swingingly: swingingly ?? self.swingingly,
3445+ unconformity: unconformity ?? self.unconformity,
3446+ undecreed: undecreed ?? self.undecreed,
3447+ venerable: venerable ?? self.venerable,
3448+ vowellessness: vowellessness ?? self.vowellessness
3449+ )
3450+ }
3451+
3452+ func jsonData() throws -> Data {
3453+ return try newJSONEncoder().encode(self)
3454+ }
3455+
3456+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3457+ return String(data: try self.jsonData(), encoding: encoding)
3458+ }
3459+}
3460+
3461+extension TopLevel.WrothyClass {
3462+ init(data: Data) throws {
3463+ self = try newJSONDecoder().decode(TopLevel.WrothyClass.self, from: data)
3464+ }
3465+
3466+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3467+ guard let data = json.data(using: encoding) else {
3468+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3469+ }
3470+ try self.init(data: data)
3471+ }
3472+
3473+ init(fromURL url: URL) throws {
3474+ try self.init(data: try Data(contentsOf: url))
3475+ }
3476+
3477+ func with(
3478+ aeschynanthus: JSONNull?? = nil,
3479+ aquiferous: JSONNull?? = nil,
3480+ cheapener: JSONNull?? = nil,
3481+ enumeration: JSONNull?? = nil,
3482+ ephesine: JSONNull?? = nil,
3483+ escadrille: JSONNull?? = nil,
3484+ estrous: JSONNull?? = nil,
3485+ interestedly: JSONNull?? = nil,
3486+ katakinetomer: JSONNull?? = nil,
3487+ mortification: JSONNull?? = nil,
3488+ morula: JSONNull?? = nil,
3489+ orthosymmetrical: JSONNull?? = nil,
3490+ overbark: JSONNull?? = nil,
3491+ politist: JSONNull?? = nil,
3492+ qualified: JSONNull?? = nil,
3493+ sphenomalar: JSONNull?? = nil,
3494+ throatful: JSONNull?? = nil,
3495+ transhumance: JSONNull?? = nil,
3496+ triandrian: JSONNull?? = nil,
3497+ unbooked: JSONNull?? = nil
3498+ ) -> TopLevel.WrothyClass {
3499+ return TopLevel.WrothyClass(
3500+ aeschynanthus: aeschynanthus ?? self.aeschynanthus,
3501+ aquiferous: aquiferous ?? self.aquiferous,
3502+ cheapener: cheapener ?? self.cheapener,
3503+ enumeration: enumeration ?? self.enumeration,
3504+ ephesine: ephesine ?? self.ephesine,
3505+ escadrille: escadrille ?? self.escadrille,
3506+ estrous: estrous ?? self.estrous,
3507+ interestedly: interestedly ?? self.interestedly,
3508+ katakinetomer: katakinetomer ?? self.katakinetomer,
3509+ mortification: mortification ?? self.mortification,
3510+ morula: morula ?? self.morula,
3511+ orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical,
3512+ overbark: overbark ?? self.overbark,
3513+ politist: politist ?? self.politist,
3514+ qualified: qualified ?? self.qualified,
3515+ sphenomalar: sphenomalar ?? self.sphenomalar,
3516+ throatful: throatful ?? self.throatful,
3517+ transhumance: transhumance ?? self.transhumance,
3518+ triandrian: triandrian ?? self.triandrian,
3519+ unbooked: unbooked ?? self.unbooked
3520+ )
3521+ }
3522+
3523+ func jsonData() throws -> Data {
3524+ return try newJSONEncoder().encode(self)
3525+ }
3526+
3527+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3528+ return String(data: try self.jsonData(), encoding: encoding)
3529+ }
3530+}
3531+
3532+// MARK: - Helper functions for creating encoders and decoders
3533+
3534+func newJSONDecoder() -> JSONDecoder {
3535+ let decoder = JSONDecoder()
3536+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
3537+ let container = try decoder.singleValueContainer()
3538+ let dateStr = try container.decode(String.self)
3539+
3540+ let formatter = DateFormatter()
3541+ formatter.calendar = Calendar(identifier: .iso8601)
3542+ formatter.locale = Locale(identifier: "en_US_POSIX")
3543+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3544+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
3545+ if let date = formatter.date(from: dateStr) {
3546+ return date
3547+ }
3548+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3549+ if let date = formatter.date(from: dateStr) {
3550+ return date
3551+ }
3552+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
3553+ })
3554+ return decoder
3555+}
3556+
3557+func newJSONEncoder() -> JSONEncoder {
3558+ let encoder = JSONEncoder()
3559+ let formatter = DateFormatter()
3560+ formatter.calendar = Calendar(identifier: .iso8601)
3561+ formatter.locale = Locale(identifier: "en_US_POSIX")
3562+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
3563+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
3564+ encoder.dateEncodingStrategy = .formatted(formatter)
3565+ return encoder
3566+}
3567+
3568+// MARK: - Encode/decode helpers
3569+
3570+class JSONNull: Codable, Hashable {
3571+
3572+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3573+ return true
3574+ }
3575+
3576+ public func hash(into hasher: inout Hasher) {
3577+ hasher.combine(0)
3578+ }
3579+
3580+ public init() {}
3581+
3582+ public required init(from decoder: Decoder) throws {
3583+ let container = try decoder.singleValueContainer()
3584+ if !container.decodeNil() {
3585+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3586+ }
3587+ }
3588+
3589+ public func encode(to encoder: Encoder) throws {
3590+ var container = encoder.singleValueContainer()
3591+ try container.encodeNil()
3592+ }
3593+}
No generated files match these filters.