Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
5test cases
41files differ
0modified
41new
0deleted
14,891changed lines
+14,891 −0insertions / deletions
Base 10cdaef273530caef2fdf9afdc07cdd0d1f9cae7 · PR merge bc0424eceb9e86ced5c12eae25abe4a706f64f12 · Head 2d0fce3ad27a0ad5c67c5f9d83fbaf1a8e3fd293 · raw patch
Test case

test/inputs/json/priority/combinations1.json

1 generated file · +2,798 −0
Aswiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+2,798 −0
@@ -0,0 +1,2798 @@
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+ // MARK: Helper functions for creating encoders and decoders
1726+ static func newJSONDecoder() -> JSONDecoder {
1727+ let decoder = JSONDecoder()
1728+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
1729+ let container = try decoder.singleValueContainer()
1730+ let dateStr = try container.decode(String.self)
1731+
1732+ let formatter = DateFormatter()
1733+ formatter.calendar = Calendar(identifier: .iso8601)
1734+ formatter.locale = Locale(identifier: "en_US_POSIX")
1735+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
1736+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
1737+ if let date = formatter.date(from: dateStr) {
1738+ return date
1739+ }
1740+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
1741+ if let date = formatter.date(from: dateStr) {
1742+ return date
1743+ }
1744+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
1745+ })
1746+ return decoder
1747+ }
1748+
1749+ static func newJSONEncoder() -> JSONEncoder {
1750+ let encoder = JSONEncoder()
1751+ let formatter = DateFormatter()
1752+ formatter.calendar = Calendar(identifier: .iso8601)
1753+ formatter.locale = Locale(identifier: "en_US_POSIX")
1754+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
1755+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
1756+ encoder.dateEncodingStrategy = .formatted(formatter)
1757+ return encoder
1758+ }
1759+}
1760+
1761+// MARK: TopLevel convenience initializers and mutators
1762+
1763+extension TopLevel {
1764+ init(data: Data) throws {
1765+ self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data)
1766+ }
1767+
1768+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1769+ guard let data = json.data(using: encoding) else {
1770+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1771+ }
1772+ try self.init(data: data)
1773+ }
1774+
1775+ init(fromURL url: URL) throws {
1776+ try self.init(data: try Data(contentsOf: url))
1777+ }
1778+
1779+ func with(
1780+ centrodesmose: String? = nil,
1781+ cerograph: [TopLevel.CerographElement]? = nil,
1782+ chemotherapeutics: [TopLevel.ChemotherapeuticElement]? = nil,
1783+ cimelia: [TopLevel.CimeliaElement]? = nil,
1784+ citrated: Int? = nil,
1785+ clinodome: [TopLevel.Clinodome]? = nil,
1786+ coadjust: [TopLevel.CoadjustElement]? = nil,
1787+ consilience: [TopLevel.Consilience]? = nil,
1788+ constructor: [TopLevel.Constructor]? = nil,
1789+ continuative: [TopLevel.Continuative]? = nil,
1790+ credulity: [TopLevel.CredulityElement]? = nil,
1791+ creviced: [TopLevel.Creviced]? = nil,
1792+ cubiculum: [[Int?]]? = nil,
1793+ deruralize: [TopLevel.DeruralizeElement]? = nil,
1794+ diaereses: [TopLevel.DiaereseElement]? = nil,
1795+ dissolution: [[JSONNull?]?]? = nil,
1796+ downstroke: [TopLevel.Downstroke]? = nil,
1797+ electrotautomerism: [Double?]? = nil,
1798+ eleutheromania: [TopLevel.Eleutheromania]? = nil,
1799+ encrust: TopLevel.Encrust? = nil,
1800+ entomoid: [TopLevel.Entomoid]? = nil,
1801+ epipaleolithic: [TopLevel.Epipaleolithic]? = nil,
1802+ expropriable: [TopLevel.Expropriable]? = nil,
1803+ faggingly: [TopLevel.FagginglyElement]? = nil,
1804+ fenks: [TopLevel.FenkElement]? = nil,
1805+ flagmaking: [TopLevel.FlagmakingElement]? = nil,
1806+ fluorometer: [TopLevel.Fluorometer]? = nil,
1807+ fulsome: [Int?]? = nil,
1808+ fuzzy: [TopLevel.Fuzzy]? = nil,
1809+ gardenwards: [TopLevel.Gardenward]? = nil,
1810+ generalissimo: [TopLevel.Generalissimo]? = nil,
1811+ habeas: [[String: Int]?]? = nil,
1812+ hemicrystalline: [TopLevel.Hemicrystalline]? = nil,
1813+ hemocoele: [TopLevel.HemocoeleElement]? = nil,
1814+ hoister: [TopLevel.Hoister]? = nil,
1815+ hyperpiesis: [TopLevel.Hyperpiesi]? = nil,
1816+ hyppish: [TopLevel.Hyppish]? = nil,
1817+ idealizer: [TopLevel.Idealizer]? = nil,
1818+ incrustator: [TopLevel.Incrustator]? = nil,
1819+ intentiveness: [TopLevel.Intentiveness]? = nil,
1820+ interacinar: TopLevel.Interacinar? = nil,
1821+ intercorrelation: [[Int]?]? = nil,
1822+ jacutinga: [TopLevel.Jacutinga]? = nil
1823+ ) -> TopLevel {
1824+ return TopLevel(
1825+ centrodesmose: centrodesmose ?? self.centrodesmose,
1826+ cerograph: cerograph ?? self.cerograph,
1827+ chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics,
1828+ cimelia: cimelia ?? self.cimelia,
1829+ citrated: citrated ?? self.citrated,
1830+ clinodome: clinodome ?? self.clinodome,
1831+ coadjust: coadjust ?? self.coadjust,
1832+ consilience: consilience ?? self.consilience,
1833+ constructor: constructor ?? self.constructor,
1834+ continuative: continuative ?? self.continuative,
1835+ credulity: credulity ?? self.credulity,
1836+ creviced: creviced ?? self.creviced,
1837+ cubiculum: cubiculum ?? self.cubiculum,
1838+ deruralize: deruralize ?? self.deruralize,
1839+ diaereses: diaereses ?? self.diaereses,
1840+ dissolution: dissolution ?? self.dissolution,
1841+ downstroke: downstroke ?? self.downstroke,
1842+ electrotautomerism: electrotautomerism ?? self.electrotautomerism,
1843+ eleutheromania: eleutheromania ?? self.eleutheromania,
1844+ encrust: encrust ?? self.encrust,
1845+ entomoid: entomoid ?? self.entomoid,
1846+ epipaleolithic: epipaleolithic ?? self.epipaleolithic,
1847+ expropriable: expropriable ?? self.expropriable,
1848+ faggingly: faggingly ?? self.faggingly,
1849+ fenks: fenks ?? self.fenks,
1850+ flagmaking: flagmaking ?? self.flagmaking,
1851+ fluorometer: fluorometer ?? self.fluorometer,
1852+ fulsome: fulsome ?? self.fulsome,
1853+ fuzzy: fuzzy ?? self.fuzzy,
1854+ gardenwards: gardenwards ?? self.gardenwards,
1855+ generalissimo: generalissimo ?? self.generalissimo,
1856+ habeas: habeas ?? self.habeas,
1857+ hemicrystalline: hemicrystalline ?? self.hemicrystalline,
1858+ hemocoele: hemocoele ?? self.hemocoele,
1859+ hoister: hoister ?? self.hoister,
1860+ hyperpiesis: hyperpiesis ?? self.hyperpiesis,
1861+ hyppish: hyppish ?? self.hyppish,
1862+ idealizer: idealizer ?? self.idealizer,
1863+ incrustator: incrustator ?? self.incrustator,
1864+ intentiveness: intentiveness ?? self.intentiveness,
1865+ interacinar: interacinar ?? self.interacinar,
1866+ intercorrelation: intercorrelation ?? self.intercorrelation,
1867+ jacutinga: jacutinga ?? self.jacutinga
1868+ )
1869+ }
1870+
1871+ func jsonData() throws -> Data {
1872+ return try TopLevel.newJSONEncoder().encode(self)
1873+ }
1874+
1875+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1876+ return String(data: try self.jsonData(), encoding: encoding)
1877+ }
1878+}
1879+
1880+extension TopLevel.CerographClass {
1881+ init(data: Data) throws {
1882+ self = try TopLevel.newJSONDecoder().decode(TopLevel.CerographClass.self, from: data)
1883+ }
1884+
1885+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1886+ guard let data = json.data(using: encoding) else {
1887+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1888+ }
1889+ try self.init(data: data)
1890+ }
1891+
1892+ init(fromURL url: URL) throws {
1893+ try self.init(data: try Data(contentsOf: url))
1894+ }
1895+
1896+ func with(
1897+ apotropaion: JSONNull?? = nil,
1898+ casuary: JSONNull?? = nil,
1899+ creaker: JSONNull?? = nil,
1900+ disqualification: JSONNull?? = nil,
1901+ imperatorious: JSONNull?? = nil,
1902+ impermeabilize: JSONNull?? = nil,
1903+ metastoma: JSONNull?? = nil,
1904+ noctidiurnal: JSONNull?? = nil,
1905+ nonreserve: JSONNull?? = nil,
1906+ ophthalmotonometry: JSONNull?? = nil,
1907+ pailful: JSONNull?? = nil,
1908+ pigfish: JSONNull?? = nil,
1909+ pongee: JSONNull?? = nil,
1910+ prosodical: JSONNull?? = nil,
1911+ scrofuloderm: JSONNull?? = nil,
1912+ storekeeping: JSONNull?? = nil,
1913+ therologist: JSONNull?? = nil,
1914+ tolowa: JSONNull?? = nil,
1915+ tradeful: JSONNull?? = nil,
1916+ unriveting: JSONNull?? = nil
1917+ ) -> TopLevel.CerographClass {
1918+ return TopLevel.CerographClass(
1919+ apotropaion: apotropaion ?? self.apotropaion,
1920+ casuary: casuary ?? self.casuary,
1921+ creaker: creaker ?? self.creaker,
1922+ disqualification: disqualification ?? self.disqualification,
1923+ imperatorious: imperatorious ?? self.imperatorious,
1924+ impermeabilize: impermeabilize ?? self.impermeabilize,
1925+ metastoma: metastoma ?? self.metastoma,
1926+ noctidiurnal: noctidiurnal ?? self.noctidiurnal,
1927+ nonreserve: nonreserve ?? self.nonreserve,
1928+ ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry,
1929+ pailful: pailful ?? self.pailful,
1930+ pigfish: pigfish ?? self.pigfish,
1931+ pongee: pongee ?? self.pongee,
1932+ prosodical: prosodical ?? self.prosodical,
1933+ scrofuloderm: scrofuloderm ?? self.scrofuloderm,
1934+ storekeeping: storekeeping ?? self.storekeeping,
1935+ therologist: therologist ?? self.therologist,
1936+ tolowa: tolowa ?? self.tolowa,
1937+ tradeful: tradeful ?? self.tradeful,
1938+ unriveting: unriveting ?? self.unriveting
1939+ )
1940+ }
1941+
1942+ func jsonData() throws -> Data {
1943+ return try TopLevel.newJSONEncoder().encode(self)
1944+ }
1945+
1946+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1947+ return String(data: try self.jsonData(), encoding: encoding)
1948+ }
1949+}
1950+
1951+extension TopLevel.ChemotherapeuticClass {
1952+ init(data: Data) throws {
1953+ self = try TopLevel.newJSONDecoder().decode(TopLevel.ChemotherapeuticClass.self, from: data)
1954+ }
1955+
1956+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1957+ guard let data = json.data(using: encoding) else {
1958+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1959+ }
1960+ try self.init(data: data)
1961+ }
1962+
1963+ init(fromURL url: URL) throws {
1964+ try self.init(data: try Data(contentsOf: url))
1965+ }
1966+
1967+ func with(
1968+ angioneurotic: JSONNull?? = nil,
1969+ availment: JSONNull?? = nil,
1970+ bladelet: JSONNull?? = nil,
1971+ catharticalness: Double?? = nil,
1972+ caulis: JSONNull?? = nil,
1973+ chalcus: JSONNull?? = nil,
1974+ chirotherium: Int?? = nil,
1975+ disdiapason: String?? = nil,
1976+ enteradenological: JSONNull?? = nil,
1977+ homocerc: Bool?? = nil,
1978+ imporosity: JSONNull?? = nil,
1979+ insistently: JSONNull?? = nil,
1980+ intraparietal: JSONNull?? = nil,
1981+ ivied: JSONNull?? = nil,
1982+ maureen: JSONNull?? = nil,
1983+ nonbookish: JSONNull?? = nil,
1984+ nostochine: JSONNull?? = nil,
1985+ nutcracker: JSONNull?? = nil,
1986+ ofttimes: JSONNull?? = nil,
1987+ phenocryst: JSONNull?? = nil,
1988+ precoincident: JSONNull?? = nil,
1989+ ramiferous: JSONNull?? = nil,
1990+ stagmometer: JSONNull?? = nil,
1991+ tetherball: JSONNull?? = nil,
1992+ unshy: JSONNull?? = nil
1993+ ) -> TopLevel.ChemotherapeuticClass {
1994+ return TopLevel.ChemotherapeuticClass(
1995+ angioneurotic: angioneurotic ?? self.angioneurotic,
1996+ availment: availment ?? self.availment,
1997+ bladelet: bladelet ?? self.bladelet,
1998+ catharticalness: catharticalness ?? self.catharticalness,
1999+ caulis: caulis ?? self.caulis,
2000+ chalcus: chalcus ?? self.chalcus,
2001+ chirotherium: chirotherium ?? self.chirotherium,
2002+ disdiapason: disdiapason ?? self.disdiapason,
2003+ enteradenological: enteradenological ?? self.enteradenological,
2004+ homocerc: homocerc ?? self.homocerc,
2005+ imporosity: imporosity ?? self.imporosity,
2006+ insistently: insistently ?? self.insistently,
2007+ intraparietal: intraparietal ?? self.intraparietal,
2008+ ivied: ivied ?? self.ivied,
2009+ maureen: maureen ?? self.maureen,
2010+ nonbookish: nonbookish ?? self.nonbookish,
2011+ nostochine: nostochine ?? self.nostochine,
2012+ nutcracker: nutcracker ?? self.nutcracker,
2013+ ofttimes: ofttimes ?? self.ofttimes,
2014+ phenocryst: phenocryst ?? self.phenocryst,
2015+ precoincident: precoincident ?? self.precoincident,
2016+ ramiferous: ramiferous ?? self.ramiferous,
2017+ stagmometer: stagmometer ?? self.stagmometer,
2018+ tetherball: tetherball ?? self.tetherball,
2019+ unshy: unshy ?? self.unshy
2020+ )
2021+ }
2022+
2023+ func jsonData() throws -> Data {
2024+ return try TopLevel.newJSONEncoder().encode(self)
2025+ }
2026+
2027+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2028+ return String(data: try self.jsonData(), encoding: encoding)
2029+ }
2030+}
2031+
2032+extension TopLevel.CimeliaClass {
2033+ init(data: Data) throws {
2034+ self = try TopLevel.newJSONDecoder().decode(TopLevel.CimeliaClass.self, from: data)
2035+ }
2036+
2037+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2038+ guard let data = json.data(using: encoding) else {
2039+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2040+ }
2041+ try self.init(data: data)
2042+ }
2043+
2044+ init(fromURL url: URL) throws {
2045+ try self.init(data: try Data(contentsOf: url))
2046+ }
2047+
2048+ func with(
2049+ catharticalness: Double? = nil,
2050+ chirotherium: Int? = nil,
2051+ disdiapason: String? = nil,
2052+ homocerc: Bool? = nil,
2053+ nonbookish: JSONNull?? = nil
2054+ ) -> TopLevel.CimeliaClass {
2055+ return TopLevel.CimeliaClass(
2056+ catharticalness: catharticalness ?? self.catharticalness,
2057+ chirotherium: chirotherium ?? self.chirotherium,
2058+ disdiapason: disdiapason ?? self.disdiapason,
2059+ homocerc: homocerc ?? self.homocerc,
2060+ nonbookish: nonbookish ?? self.nonbookish
2061+ )
2062+ }
2063+
2064+ func jsonData() throws -> Data {
2065+ return try TopLevel.newJSONEncoder().encode(self)
2066+ }
2067+
2068+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2069+ return String(data: try self.jsonData(), encoding: encoding)
2070+ }
2071+}
2072+
2073+extension TopLevel.CoadjustClass {
2074+ init(data: Data) throws {
2075+ self = try TopLevel.newJSONDecoder().decode(TopLevel.CoadjustClass.self, from: data)
2076+ }
2077+
2078+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2079+ guard let data = json.data(using: encoding) else {
2080+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2081+ }
2082+ try self.init(data: data)
2083+ }
2084+
2085+ init(fromURL url: URL) throws {
2086+ try self.init(data: try Data(contentsOf: url))
2087+ }
2088+
2089+ func with(
2090+ amidosulphonal: JSONNull?? = nil,
2091+ benny: JSONNull?? = nil,
2092+ catharticalness: Double?? = nil,
2093+ chirotherium: Int?? = nil,
2094+ disdiapason: String?? = nil,
2095+ ensnare: JSONNull?? = nil,
2096+ homocerc: Bool?? = nil,
2097+ hybridizer: JSONNull?? = nil,
2098+ leastwise: JSONNull?? = nil,
2099+ lof: JSONNull?? = nil,
2100+ monkhood: JSONNull?? = nil,
2101+ netherlandish: JSONNull?? = nil,
2102+ nonbookish: JSONNull?? = nil,
2103+ peonism: JSONNull?? = nil,
2104+ phonelescope: JSONNull?? = nil,
2105+ porphyrogeniture: JSONNull?? = nil,
2106+ preindemnify: JSONNull?? = nil,
2107+ rosal: JSONNull?? = nil,
2108+ scalenous: JSONNull?? = nil,
2109+ scopine: JSONNull?? = nil,
2110+ sedaceae: JSONNull?? = nil,
2111+ suberinize: JSONNull?? = nil,
2112+ symbiot: JSONNull?? = nil,
2113+ tablefellow: JSONNull?? = nil,
2114+ unchargeable: JSONNull?? = nil
2115+ ) -> TopLevel.CoadjustClass {
2116+ return TopLevel.CoadjustClass(
2117+ amidosulphonal: amidosulphonal ?? self.amidosulphonal,
2118+ benny: benny ?? self.benny,
2119+ catharticalness: catharticalness ?? self.catharticalness,
2120+ chirotherium: chirotherium ?? self.chirotherium,
2121+ disdiapason: disdiapason ?? self.disdiapason,
2122+ ensnare: ensnare ?? self.ensnare,
2123+ homocerc: homocerc ?? self.homocerc,
2124+ hybridizer: hybridizer ?? self.hybridizer,
2125+ leastwise: leastwise ?? self.leastwise,
2126+ lof: lof ?? self.lof,
2127+ monkhood: monkhood ?? self.monkhood,
2128+ netherlandish: netherlandish ?? self.netherlandish,
2129+ nonbookish: nonbookish ?? self.nonbookish,
2130+ peonism: peonism ?? self.peonism,
2131+ phonelescope: phonelescope ?? self.phonelescope,
2132+ porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture,
2133+ preindemnify: preindemnify ?? self.preindemnify,
2134+ rosal: rosal ?? self.rosal,
2135+ scalenous: scalenous ?? self.scalenous,
2136+ scopine: scopine ?? self.scopine,
2137+ sedaceae: sedaceae ?? self.sedaceae,
2138+ suberinize: suberinize ?? self.suberinize,
2139+ symbiot: symbiot ?? self.symbiot,
2140+ tablefellow: tablefellow ?? self.tablefellow,
2141+ unchargeable: unchargeable ?? self.unchargeable
2142+ )
2143+ }
2144+
2145+ func jsonData() throws -> Data {
2146+ return try TopLevel.newJSONEncoder().encode(self)
2147+ }
2148+
2149+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2150+ return String(data: try self.jsonData(), encoding: encoding)
2151+ }
2152+}
2153+
2154+extension TopLevel.CredulityClass {
2155+ init(data: Data) throws {
2156+ self = try TopLevel.newJSONDecoder().decode(TopLevel.CredulityClass.self, from: data)
2157+ }
2158+
2159+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2160+ guard let data = json.data(using: encoding) else {
2161+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2162+ }
2163+ try self.init(data: data)
2164+ }
2165+
2166+ init(fromURL url: URL) throws {
2167+ try self.init(data: try Data(contentsOf: url))
2168+ }
2169+
2170+ func with(
2171+ ammonolytic: JSONNull?? = nil,
2172+ bushmaster: JSONNull?? = nil,
2173+ considering: JSONNull?? = nil,
2174+ consuetudinary: JSONNull?? = nil,
2175+ embarras: JSONNull?? = nil,
2176+ fineness: JSONNull?? = nil,
2177+ flaithship: JSONNull?? = nil,
2178+ flavia: JSONNull?? = nil,
2179+ gruffly: JSONNull?? = nil,
2180+ hedychium: JSONNull?? = nil,
2181+ leadwort: JSONNull?? = nil,
2182+ overseriously: JSONNull?? = nil,
2183+ parabola: JSONNull?? = nil,
2184+ pectinatodenticulate: JSONNull?? = nil,
2185+ popean: JSONNull?? = nil,
2186+ pornocrat: JSONNull?? = nil,
2187+ quadrisect: JSONNull?? = nil,
2188+ seriality: JSONNull?? = nil,
2189+ vamphorn: JSONNull?? = nil,
2190+ wharp: JSONNull?? = nil
2191+ ) -> TopLevel.CredulityClass {
2192+ return TopLevel.CredulityClass(
2193+ ammonolytic: ammonolytic ?? self.ammonolytic,
2194+ bushmaster: bushmaster ?? self.bushmaster,
2195+ considering: considering ?? self.considering,
2196+ consuetudinary: consuetudinary ?? self.consuetudinary,
2197+ embarras: embarras ?? self.embarras,
2198+ fineness: fineness ?? self.fineness,
2199+ flaithship: flaithship ?? self.flaithship,
2200+ flavia: flavia ?? self.flavia,
2201+ gruffly: gruffly ?? self.gruffly,
2202+ hedychium: hedychium ?? self.hedychium,
2203+ leadwort: leadwort ?? self.leadwort,
2204+ overseriously: overseriously ?? self.overseriously,
2205+ parabola: parabola ?? self.parabola,
2206+ pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate,
2207+ popean: popean ?? self.popean,
2208+ pornocrat: pornocrat ?? self.pornocrat,
2209+ quadrisect: quadrisect ?? self.quadrisect,
2210+ seriality: seriality ?? self.seriality,
2211+ vamphorn: vamphorn ?? self.vamphorn,
2212+ wharp: wharp ?? self.wharp
2213+ )
2214+ }
2215+
2216+ func jsonData() throws -> Data {
2217+ return try TopLevel.newJSONEncoder().encode(self)
2218+ }
2219+
2220+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2221+ return String(data: try self.jsonData(), encoding: encoding)
2222+ }
2223+}
2224+
2225+extension TopLevel.DeruralizeClass {
2226+ init(data: Data) throws {
2227+ self = try TopLevel.newJSONDecoder().decode(TopLevel.DeruralizeClass.self, from: data)
2228+ }
2229+
2230+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2231+ guard let data = json.data(using: encoding) else {
2232+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2233+ }
2234+ try self.init(data: data)
2235+ }
2236+
2237+ init(fromURL url: URL) throws {
2238+ try self.init(data: try Data(contentsOf: url))
2239+ }
2240+
2241+ func with(
2242+ bockerel: JSONNull?? = nil,
2243+ boulder: JSONNull?? = nil,
2244+ churrus: JSONNull?? = nil,
2245+ counterdigged: JSONNull?? = nil,
2246+ dialogite: JSONNull?? = nil,
2247+ digenic: JSONNull?? = nil,
2248+ dunbird: JSONNull?? = nil,
2249+ ergatogyne: JSONNull?? = nil,
2250+ fiendful: JSONNull?? = nil,
2251+ jackrod: JSONNull?? = nil,
2252+ jehovistic: JSONNull?? = nil,
2253+ paninean: JSONNull?? = nil,
2254+ panther: JSONNull?? = nil,
2255+ placentigerous: JSONNull?? = nil,
2256+ romney: JSONNull?? = nil,
2257+ sparm: JSONNull?? = nil,
2258+ tocsin: JSONNull?? = nil,
2259+ unnicked: JSONNull?? = nil,
2260+ unstavable: JSONNull?? = nil,
2261+ windfirm: JSONNull?? = nil
2262+ ) -> TopLevel.DeruralizeClass {
2263+ return TopLevel.DeruralizeClass(
2264+ bockerel: bockerel ?? self.bockerel,
2265+ boulder: boulder ?? self.boulder,
2266+ churrus: churrus ?? self.churrus,
2267+ counterdigged: counterdigged ?? self.counterdigged,
2268+ dialogite: dialogite ?? self.dialogite,
2269+ digenic: digenic ?? self.digenic,
2270+ dunbird: dunbird ?? self.dunbird,
2271+ ergatogyne: ergatogyne ?? self.ergatogyne,
2272+ fiendful: fiendful ?? self.fiendful,
2273+ jackrod: jackrod ?? self.jackrod,
2274+ jehovistic: jehovistic ?? self.jehovistic,
2275+ paninean: paninean ?? self.paninean,
2276+ panther: panther ?? self.panther,
2277+ placentigerous: placentigerous ?? self.placentigerous,
2278+ romney: romney ?? self.romney,
2279+ sparm: sparm ?? self.sparm,
2280+ tocsin: tocsin ?? self.tocsin,
2281+ unnicked: unnicked ?? self.unnicked,
2282+ unstavable: unstavable ?? self.unstavable,
2283+ windfirm: windfirm ?? self.windfirm
2284+ )
2285+ }
2286+
2287+ func jsonData() throws -> Data {
2288+ return try TopLevel.newJSONEncoder().encode(self)
2289+ }
2290+
2291+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2292+ return String(data: try self.jsonData(), encoding: encoding)
2293+ }
2294+}
2295+
2296+extension TopLevel.DiaereseClass {
2297+ init(data: Data) throws {
2298+ self = try TopLevel.newJSONDecoder().decode(TopLevel.DiaereseClass.self, from: data)
2299+ }
2300+
2301+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2302+ guard let data = json.data(using: encoding) else {
2303+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2304+ }
2305+ try self.init(data: data)
2306+ }
2307+
2308+ init(fromURL url: URL) throws {
2309+ try self.init(data: try Data(contentsOf: url))
2310+ }
2311+
2312+ func with(
2313+ amoreuxia: JSONNull?? = nil,
2314+ ani: JSONNull?? = nil,
2315+ bernicle: JSONNull?? = nil,
2316+ blackwasher: JSONNull?? = nil,
2317+ blowhard: JSONNull?? = nil,
2318+ broma: JSONNull?? = nil,
2319+ closecross: JSONNull?? = nil,
2320+ congregationalism: JSONNull?? = nil,
2321+ grayly: JSONNull?? = nil,
2322+ historically: JSONNull?? = nil,
2323+ hoast: JSONNull?? = nil,
2324+ irretentive: JSONNull?? = nil,
2325+ parcener: JSONNull?? = nil,
2326+ pedder: JSONNull?? = nil,
2327+ pseudoanatomic: JSONNull?? = nil,
2328+ rhizocarpian: JSONNull?? = nil,
2329+ samel: JSONNull?? = nil,
2330+ silker: JSONNull?? = nil,
2331+ subdentated: JSONNull?? = nil,
2332+ subobscure: JSONNull?? = nil
2333+ ) -> TopLevel.DiaereseClass {
2334+ return TopLevel.DiaereseClass(
2335+ amoreuxia: amoreuxia ?? self.amoreuxia,
2336+ ani: ani ?? self.ani,
2337+ bernicle: bernicle ?? self.bernicle,
2338+ blackwasher: blackwasher ?? self.blackwasher,
2339+ blowhard: blowhard ?? self.blowhard,
2340+ broma: broma ?? self.broma,
2341+ closecross: closecross ?? self.closecross,
2342+ congregationalism: congregationalism ?? self.congregationalism,
2343+ grayly: grayly ?? self.grayly,
2344+ historically: historically ?? self.historically,
2345+ hoast: hoast ?? self.hoast,
2346+ irretentive: irretentive ?? self.irretentive,
2347+ parcener: parcener ?? self.parcener,
2348+ pedder: pedder ?? self.pedder,
2349+ pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic,
2350+ rhizocarpian: rhizocarpian ?? self.rhizocarpian,
2351+ samel: samel ?? self.samel,
2352+ silker: silker ?? self.silker,
2353+ subdentated: subdentated ?? self.subdentated,
2354+ subobscure: subobscure ?? self.subobscure
2355+ )
2356+ }
2357+
2358+ func jsonData() throws -> Data {
2359+ return try TopLevel.newJSONEncoder().encode(self)
2360+ }
2361+
2362+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2363+ return String(data: try self.jsonData(), encoding: encoding)
2364+ }
2365+}
2366+
2367+extension TopLevel.Encrust {
2368+ init(data: Data) throws {
2369+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Encrust.self, from: data)
2370+ }
2371+
2372+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2373+ guard let data = json.data(using: encoding) else {
2374+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2375+ }
2376+ try self.init(data: data)
2377+ }
2378+
2379+ init(fromURL url: URL) throws {
2380+ try self.init(data: try Data(contentsOf: url))
2381+ }
2382+
2383+ func with(
2384+ comradely: JSONNull?? = nil,
2385+ diacanthous: JSONNull?? = nil,
2386+ feminineness: JSONNull?? = nil,
2387+ gossamered: JSONNull?? = nil,
2388+ hibernia: JSONNull?? = nil,
2389+ hibiscus: JSONNull?? = nil,
2390+ lepidosauria: JSONNull?? = nil,
2391+ lollingly: JSONNull?? = nil,
2392+ manager: JSONNull?? = nil,
2393+ mechanic: JSONNull?? = nil,
2394+ overminuteness: JSONNull?? = nil,
2395+ papelonne: JSONNull?? = nil,
2396+ plebification: JSONNull?? = nil,
2397+ pugmiller: JSONNull?? = nil,
2398+ recoveror: JSONNull?? = nil,
2399+ spermatoblastic: JSONNull?? = nil,
2400+ syllidae: JSONNull?? = nil,
2401+ ungyved: JSONNull?? = nil,
2402+ whirlabout: JSONNull?? = nil,
2403+ woodenware: JSONNull?? = nil
2404+ ) -> TopLevel.Encrust {
2405+ return TopLevel.Encrust(
2406+ comradely: comradely ?? self.comradely,
2407+ diacanthous: diacanthous ?? self.diacanthous,
2408+ feminineness: feminineness ?? self.feminineness,
2409+ gossamered: gossamered ?? self.gossamered,
2410+ hibernia: hibernia ?? self.hibernia,
2411+ hibiscus: hibiscus ?? self.hibiscus,
2412+ lepidosauria: lepidosauria ?? self.lepidosauria,
2413+ lollingly: lollingly ?? self.lollingly,
2414+ manager: manager ?? self.manager,
2415+ mechanic: mechanic ?? self.mechanic,
2416+ overminuteness: overminuteness ?? self.overminuteness,
2417+ papelonne: papelonne ?? self.papelonne,
2418+ plebification: plebification ?? self.plebification,
2419+ pugmiller: pugmiller ?? self.pugmiller,
2420+ recoveror: recoveror ?? self.recoveror,
2421+ spermatoblastic: spermatoblastic ?? self.spermatoblastic,
2422+ syllidae: syllidae ?? self.syllidae,
2423+ ungyved: ungyved ?? self.ungyved,
2424+ whirlabout: whirlabout ?? self.whirlabout,
2425+ woodenware: woodenware ?? self.woodenware
2426+ )
2427+ }
2428+
2429+ func jsonData() throws -> Data {
2430+ return try TopLevel.newJSONEncoder().encode(self)
2431+ }
2432+
2433+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2434+ return String(data: try self.jsonData(), encoding: encoding)
2435+ }
2436+}
2437+
2438+extension TopLevel.FagginglyClass {
2439+ init(data: Data) throws {
2440+ self = try TopLevel.newJSONDecoder().decode(TopLevel.FagginglyClass.self, from: data)
2441+ }
2442+
2443+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2444+ guard let data = json.data(using: encoding) else {
2445+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2446+ }
2447+ try self.init(data: data)
2448+ }
2449+
2450+ init(fromURL url: URL) throws {
2451+ try self.init(data: try Data(contentsOf: url))
2452+ }
2453+
2454+ func with(
2455+ abranchian: JSONNull?? = nil,
2456+ aculeiform: JSONNull?? = nil,
2457+ adiaphoristic: JSONNull?? = nil,
2458+ adoptionism: JSONNull?? = nil,
2459+ anglic: JSONNull?? = nil,
2460+ antrotomy: JSONNull?? = nil,
2461+ coerciveness: JSONNull?? = nil,
2462+ decorist: JSONNull?? = nil,
2463+ duckhood: JSONNull?? = nil,
2464+ heteromeri: JSONNull?? = nil,
2465+ hypochnose: JSONNull?? = nil,
2466+ lochage: JSONNull?? = nil,
2467+ melee: JSONNull?? = nil,
2468+ nonconformitant: JSONNull?? = nil,
2469+ poinsettia: JSONNull?? = nil,
2470+ putatively: JSONNull?? = nil,
2471+ semivolatile: JSONNull?? = nil,
2472+ soleas: JSONNull?? = nil,
2473+ unfastenable: JSONNull?? = nil,
2474+ unmillinered: JSONNull?? = nil
2475+ ) -> TopLevel.FagginglyClass {
2476+ return TopLevel.FagginglyClass(
2477+ abranchian: abranchian ?? self.abranchian,
2478+ aculeiform: aculeiform ?? self.aculeiform,
2479+ adiaphoristic: adiaphoristic ?? self.adiaphoristic,
2480+ adoptionism: adoptionism ?? self.adoptionism,
2481+ anglic: anglic ?? self.anglic,
2482+ antrotomy: antrotomy ?? self.antrotomy,
2483+ coerciveness: coerciveness ?? self.coerciveness,
2484+ decorist: decorist ?? self.decorist,
2485+ duckhood: duckhood ?? self.duckhood,
2486+ heteromeri: heteromeri ?? self.heteromeri,
2487+ hypochnose: hypochnose ?? self.hypochnose,
2488+ lochage: lochage ?? self.lochage,
2489+ melee: melee ?? self.melee,
2490+ nonconformitant: nonconformitant ?? self.nonconformitant,
2491+ poinsettia: poinsettia ?? self.poinsettia,
2492+ putatively: putatively ?? self.putatively,
2493+ semivolatile: semivolatile ?? self.semivolatile,
2494+ soleas: soleas ?? self.soleas,
2495+ unfastenable: unfastenable ?? self.unfastenable,
2496+ unmillinered: unmillinered ?? self.unmillinered
2497+ )
2498+ }
2499+
2500+ func jsonData() throws -> Data {
2501+ return try TopLevel.newJSONEncoder().encode(self)
2502+ }
2503+
2504+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2505+ return String(data: try self.jsonData(), encoding: encoding)
2506+ }
2507+}
2508+
2509+extension TopLevel.FenkClass {
2510+ init(data: Data) throws {
2511+ self = try TopLevel.newJSONDecoder().decode(TopLevel.FenkClass.self, from: data)
2512+ }
2513+
2514+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2515+ guard let data = json.data(using: encoding) else {
2516+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2517+ }
2518+ try self.init(data: data)
2519+ }
2520+
2521+ init(fromURL url: URL) throws {
2522+ try self.init(data: try Data(contentsOf: url))
2523+ }
2524+
2525+ func with(
2526+ apoise: JSONNull?? = nil,
2527+ astronomize: JSONNull?? = nil,
2528+ cockhorse: JSONNull?? = nil,
2529+ copular: JSONNull?? = nil,
2530+ dagomba: JSONNull?? = nil,
2531+ draffy: JSONNull?? = nil,
2532+ foreigner: JSONNull?? = nil,
2533+ guyandot: JSONNull?? = nil,
2534+ neurogliosis: JSONNull?? = nil,
2535+ osmious: JSONNull?? = nil,
2536+ palpitate: JSONNull?? = nil,
2537+ rebukeable: JSONNull?? = nil,
2538+ reinwardtia: JSONNull?? = nil,
2539+ reservatory: JSONNull?? = nil,
2540+ scalt: JSONNull?? = nil,
2541+ scripturalize: JSONNull?? = nil,
2542+ tintometer: JSONNull?? = nil,
2543+ tritoness: JSONNull?? = nil,
2544+ undergrade: JSONNull?? = nil,
2545+ undermountain: JSONNull?? = nil
2546+ ) -> TopLevel.FenkClass {
2547+ return TopLevel.FenkClass(
2548+ apoise: apoise ?? self.apoise,
2549+ astronomize: astronomize ?? self.astronomize,
2550+ cockhorse: cockhorse ?? self.cockhorse,
2551+ copular: copular ?? self.copular,
2552+ dagomba: dagomba ?? self.dagomba,
2553+ draffy: draffy ?? self.draffy,
2554+ foreigner: foreigner ?? self.foreigner,
2555+ guyandot: guyandot ?? self.guyandot,
2556+ neurogliosis: neurogliosis ?? self.neurogliosis,
2557+ osmious: osmious ?? self.osmious,
2558+ palpitate: palpitate ?? self.palpitate,
2559+ rebukeable: rebukeable ?? self.rebukeable,
2560+ reinwardtia: reinwardtia ?? self.reinwardtia,
2561+ reservatory: reservatory ?? self.reservatory,
2562+ scalt: scalt ?? self.scalt,
2563+ scripturalize: scripturalize ?? self.scripturalize,
2564+ tintometer: tintometer ?? self.tintometer,
2565+ tritoness: tritoness ?? self.tritoness,
2566+ undergrade: undergrade ?? self.undergrade,
2567+ undermountain: undermountain ?? self.undermountain
2568+ )
2569+ }
2570+
2571+ func jsonData() throws -> Data {
2572+ return try TopLevel.newJSONEncoder().encode(self)
2573+ }
2574+
2575+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2576+ return String(data: try self.jsonData(), encoding: encoding)
2577+ }
2578+}
2579+
2580+extension TopLevel.FlagmakingClass {
2581+ init(data: Data) throws {
2582+ self = try TopLevel.newJSONDecoder().decode(TopLevel.FlagmakingClass.self, from: data)
2583+ }
2584+
2585+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2586+ guard let data = json.data(using: encoding) else {
2587+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2588+ }
2589+ try self.init(data: data)
2590+ }
2591+
2592+ init(fromURL url: URL) throws {
2593+ try self.init(data: try Data(contentsOf: url))
2594+ }
2595+
2596+ func with(
2597+ albarco: JSONNull?? = nil,
2598+ bunodonta: JSONNull?? = nil,
2599+ hornify: JSONNull?? = nil,
2600+ hydrocorisae: JSONNull?? = nil,
2601+ hypoglossus: JSONNull?? = nil,
2602+ inexpiably: JSONNull?? = nil,
2603+ ingratitude: JSONNull?? = nil,
2604+ ladyfly: JSONNull?? = nil,
2605+ medicament: JSONNull?? = nil,
2606+ monogrammatic: JSONNull?? = nil,
2607+ nobbut: JSONNull?? = nil,
2608+ notacanthidae: JSONNull?? = nil,
2609+ polyplacophore: JSONNull?? = nil,
2610+ proexercise: JSONNull?? = nil,
2611+ protoplast: JSONNull?? = nil,
2612+ puzzling: JSONNull?? = nil,
2613+ splanchnoskeleton: JSONNull?? = nil,
2614+ unloveliness: JSONNull?? = nil,
2615+ unquarantined: JSONNull?? = nil,
2616+ unrenounceable: JSONNull?? = nil
2617+ ) -> TopLevel.FlagmakingClass {
2618+ return TopLevel.FlagmakingClass(
2619+ albarco: albarco ?? self.albarco,
2620+ bunodonta: bunodonta ?? self.bunodonta,
2621+ hornify: hornify ?? self.hornify,
2622+ hydrocorisae: hydrocorisae ?? self.hydrocorisae,
2623+ hypoglossus: hypoglossus ?? self.hypoglossus,
2624+ inexpiably: inexpiably ?? self.inexpiably,
2625+ ingratitude: ingratitude ?? self.ingratitude,
2626+ ladyfly: ladyfly ?? self.ladyfly,
2627+ medicament: medicament ?? self.medicament,
2628+ monogrammatic: monogrammatic ?? self.monogrammatic,
2629+ nobbut: nobbut ?? self.nobbut,
2630+ notacanthidae: notacanthidae ?? self.notacanthidae,
2631+ polyplacophore: polyplacophore ?? self.polyplacophore,
2632+ proexercise: proexercise ?? self.proexercise,
2633+ protoplast: protoplast ?? self.protoplast,
2634+ puzzling: puzzling ?? self.puzzling,
2635+ splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton,
2636+ unloveliness: unloveliness ?? self.unloveliness,
2637+ unquarantined: unquarantined ?? self.unquarantined,
2638+ unrenounceable: unrenounceable ?? self.unrenounceable
2639+ )
2640+ }
2641+
2642+ func jsonData() throws -> Data {
2643+ return try TopLevel.newJSONEncoder().encode(self)
2644+ }
2645+
2646+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2647+ return String(data: try self.jsonData(), encoding: encoding)
2648+ }
2649+}
2650+
2651+extension TopLevel.HemocoeleClass {
2652+ init(data: Data) throws {
2653+ self = try TopLevel.newJSONDecoder().decode(TopLevel.HemocoeleClass.self, from: data)
2654+ }
2655+
2656+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2657+ guard let data = json.data(using: encoding) else {
2658+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2659+ }
2660+ try self.init(data: data)
2661+ }
2662+
2663+ init(fromURL url: URL) throws {
2664+ try self.init(data: try Data(contentsOf: url))
2665+ }
2666+
2667+ func with(
2668+ acrogamy: JSONNull?? = nil,
2669+ amelification: JSONNull?? = nil,
2670+ autobiographic: JSONNull?? = nil,
2671+ berat: JSONNull?? = nil,
2672+ catharticalness: Double?? = nil,
2673+ chirotherium: Int?? = nil,
2674+ disdiapason: String?? = nil,
2675+ disproportionably: JSONNull?? = nil,
2676+ erythrite: JSONNull?? = nil,
2677+ graphic: JSONNull?? = nil,
2678+ hepatological: JSONNull?? = nil,
2679+ homocerc: Bool?? = nil,
2680+ incommensurably: JSONNull?? = nil,
2681+ misaffirm: JSONNull?? = nil,
2682+ nonbookish: JSONNull?? = nil,
2683+ pocketbook: JSONNull?? = nil,
2684+ sclerometric: JSONNull?? = nil,
2685+ stambouline: JSONNull?? = nil,
2686+ stickpin: JSONNull?? = nil,
2687+ tubulure: JSONNull?? = nil,
2688+ undelated: JSONNull?? = nil,
2689+ unsalt: JSONNull?? = nil,
2690+ untutelar: JSONNull?? = nil,
2691+ vagrant: JSONNull?? = nil,
2692+ walt: JSONNull?? = nil
2693+ ) -> TopLevel.HemocoeleClass {
2694+ return TopLevel.HemocoeleClass(
2695+ acrogamy: acrogamy ?? self.acrogamy,
2696+ amelification: amelification ?? self.amelification,
2697+ autobiographic: autobiographic ?? self.autobiographic,
2698+ berat: berat ?? self.berat,
2699+ catharticalness: catharticalness ?? self.catharticalness,
2700+ chirotherium: chirotherium ?? self.chirotherium,
2701+ disdiapason: disdiapason ?? self.disdiapason,
2702+ disproportionably: disproportionably ?? self.disproportionably,
2703+ erythrite: erythrite ?? self.erythrite,
2704+ graphic: graphic ?? self.graphic,
2705+ hepatological: hepatological ?? self.hepatological,
2706+ homocerc: homocerc ?? self.homocerc,
2707+ incommensurably: incommensurably ?? self.incommensurably,
2708+ misaffirm: misaffirm ?? self.misaffirm,
2709+ nonbookish: nonbookish ?? self.nonbookish,
2710+ pocketbook: pocketbook ?? self.pocketbook,
2711+ sclerometric: sclerometric ?? self.sclerometric,
2712+ stambouline: stambouline ?? self.stambouline,
2713+ stickpin: stickpin ?? self.stickpin,
2714+ tubulure: tubulure ?? self.tubulure,
2715+ undelated: undelated ?? self.undelated,
2716+ unsalt: unsalt ?? self.unsalt,
2717+ untutelar: untutelar ?? self.untutelar,
2718+ vagrant: vagrant ?? self.vagrant,
2719+ walt: walt ?? self.walt
2720+ )
2721+ }
2722+
2723+ func jsonData() throws -> Data {
2724+ return try TopLevel.newJSONEncoder().encode(self)
2725+ }
2726+
2727+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2728+ return String(data: try self.jsonData(), encoding: encoding)
2729+ }
2730+}
2731+
2732+extension TopLevel.Interacinar {
2733+ init(data: Data) throws {
2734+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Interacinar.self, from: data)
2735+ }
2736+
2737+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2738+ guard let data = json.data(using: encoding) else {
2739+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2740+ }
2741+ try self.init(data: data)
2742+ }
2743+
2744+ init(fromURL url: URL) throws {
2745+ try self.init(data: try Data(contentsOf: url))
2746+ }
2747+
2748+ func with(
2749+ assapan: Double? = nil,
2750+ benefactorship: Bool? = nil,
2751+ triseriatim: String? = nil,
2752+ tubbing: Int? = nil,
2753+ untrimmed: JSONNull?? = nil
2754+ ) -> TopLevel.Interacinar {
2755+ return TopLevel.Interacinar(
2756+ assapan: assapan ?? self.assapan,
2757+ benefactorship: benefactorship ?? self.benefactorship,
2758+ triseriatim: triseriatim ?? self.triseriatim,
2759+ tubbing: tubbing ?? self.tubbing,
2760+ untrimmed: untrimmed ?? self.untrimmed
2761+ )
2762+ }
2763+
2764+ func jsonData() throws -> Data {
2765+ return try TopLevel.newJSONEncoder().encode(self)
2766+ }
2767+
2768+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2769+ return String(data: try self.jsonData(), encoding: encoding)
2770+ }
2771+}
2772+
2773+// MARK: - Encode/decode helpers
2774+
2775+class JSONNull: Codable, Hashable {
2776+
2777+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
2778+ return true
2779+ }
2780+
2781+ public func hash(into hasher: inout Hasher) {
2782+ hasher.combine(0)
2783+ }
2784+
2785+ public init() {}
2786+
2787+ public required init(from decoder: Decoder) throws {
2788+ let container = try decoder.singleValueContainer()
2789+ if !container.decodeNil() {
2790+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
2791+ }
2792+ }
2793+
2794+ public func encode(to encoder: Encoder) throws {
2795+ var container = encoder.singleValueContainer()
2796+ try container.encodeNil()
2797+ }
2798+}
Test case

test/inputs/json/priority/combinations2.json

1 generated file · +2,571 −0
Aswiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+2,571 −0
@@ -0,0 +1,2571 @@
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+ // MARK: Helper functions for creating encoders and decoders
1678+ static func newJSONDecoder() -> JSONDecoder {
1679+ let decoder = JSONDecoder()
1680+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
1681+ let container = try decoder.singleValueContainer()
1682+ let dateStr = try container.decode(String.self)
1683+
1684+ let formatter = DateFormatter()
1685+ formatter.calendar = Calendar(identifier: .iso8601)
1686+ formatter.locale = Locale(identifier: "en_US_POSIX")
1687+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
1688+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
1689+ if let date = formatter.date(from: dateStr) {
1690+ return date
1691+ }
1692+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
1693+ if let date = formatter.date(from: dateStr) {
1694+ return date
1695+ }
1696+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
1697+ })
1698+ return decoder
1699+ }
1700+
1701+ static func newJSONEncoder() -> JSONEncoder {
1702+ let encoder = JSONEncoder()
1703+ let formatter = DateFormatter()
1704+ formatter.calendar = Calendar(identifier: .iso8601)
1705+ formatter.locale = Locale(identifier: "en_US_POSIX")
1706+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
1707+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
1708+ encoder.dateEncodingStrategy = .formatted(formatter)
1709+ return encoder
1710+ }
1711+}
1712+
1713+// MARK: TopLevel convenience initializers and mutators
1714+
1715+extension TopLevel {
1716+ init(data: Data) throws {
1717+ self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data)
1718+ }
1719+
1720+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1721+ guard let data = json.data(using: encoding) else {
1722+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1723+ }
1724+ try self.init(data: data)
1725+ }
1726+
1727+ init(fromURL url: URL) throws {
1728+ try self.init(data: try Data(contentsOf: url))
1729+ }
1730+
1731+ func with(
1732+ abranchiata: [TopLevel.Abranchiata]? = nil,
1733+ academe: [TopLevel.Academe]? = nil,
1734+ acquirable: [TopLevel.Acquirable]? = nil,
1735+ aerometry: [TopLevel.Aerometry]? = nil,
1736+ alexin: [TopLevel.Alexin]? = nil,
1737+ alleviate: [TopLevel.AlleviateElement]? = nil,
1738+ amaas: [TopLevel.Amaa]? = nil,
1739+ ambassage: [TopLevel.Ambassage]? = nil,
1740+ amphithyron: [TopLevel.Amphithyron?]? = nil,
1741+ andriana: [String?]? = nil,
1742+ ankee: [TopLevel.AnkeeElement]? = nil,
1743+ annihilator: [[String: Int?]?]? = nil,
1744+ annulose: JSONNull?? = nil,
1745+ ansarie: [TopLevel.AnsarieElement]? = nil,
1746+ aphasia: [TopLevel.Aphasia]? = nil,
1747+ asprawl: [TopLevel.Asprawl]? = nil,
1748+ attractive: [Bool?]? = nil,
1749+ barksome: [String: Int]? = nil,
1750+ bedesman: [TopLevel.Bedesman]? = nil,
1751+ belard: [TopLevel.Belard]? = nil,
1752+ bocking: [TopLevel.Bocking]? = nil,
1753+ brawlingly: [TopLevel.Brawlingly]? = nil,
1754+ brookie: [TopLevel.Brookie]? = nil,
1755+ bumboatman: [TopLevel.Bumboatman]? = nil,
1756+ bystreet: [JSONNull?]? = nil,
1757+ calaverite: [TopLevel.Calaverite]? = nil,
1758+ catallactic: [TopLevel.Catallactic]? = nil,
1759+ cemental: [TopLevel.Cemental]? = nil,
1760+ chytridiaceae: [TopLevel.ChytridiaceaeElement]? = nil,
1761+ discordia: [TopLevel.DiscordiaElement]? = nil,
1762+ endomyces: [TopLevel.Endomyce]? = nil,
1763+ epinephelidae: [TopLevel.Epinephelidae]? = nil,
1764+ eupatorium: [TopLevel.Eupatorium]? = nil,
1765+ gryphosaurus: [TopLevel.GryphosaurusElement]? = nil,
1766+ koryak: [TopLevel.Koryak]? = nil,
1767+ lavinia: [TopLevel.LaviniaElement]? = nil,
1768+ oskar: [TopLevel.OskarElement]? = nil,
1769+ rebecca: [TopLevel.RebeccaElement]? = nil,
1770+ rhomboganoidei: [TopLevel.Rhomboganoidei]? = nil,
1771+ rigsmal: Bool? = nil,
1772+ ruellia: [TopLevel.Ruellia]? = nil,
1773+ school: [TopLevel.School]? = nil,
1774+ shakespearolater: [TopLevel.Shakespearolater]? = nil,
1775+ svan: [Double]? = nil,
1776+ wayao: [String: Double]? = nil
1777+ ) -> TopLevel {
1778+ return TopLevel(
1779+ abranchiata: abranchiata ?? self.abranchiata,
1780+ academe: academe ?? self.academe,
1781+ acquirable: acquirable ?? self.acquirable,
1782+ aerometry: aerometry ?? self.aerometry,
1783+ alexin: alexin ?? self.alexin,
1784+ alleviate: alleviate ?? self.alleviate,
1785+ amaas: amaas ?? self.amaas,
1786+ ambassage: ambassage ?? self.ambassage,
1787+ amphithyron: amphithyron ?? self.amphithyron,
1788+ andriana: andriana ?? self.andriana,
1789+ ankee: ankee ?? self.ankee,
1790+ annihilator: annihilator ?? self.annihilator,
1791+ annulose: annulose ?? self.annulose,
1792+ ansarie: ansarie ?? self.ansarie,
1793+ aphasia: aphasia ?? self.aphasia,
1794+ asprawl: asprawl ?? self.asprawl,
1795+ attractive: attractive ?? self.attractive,
1796+ barksome: barksome ?? self.barksome,
1797+ bedesman: bedesman ?? self.bedesman,
1798+ belard: belard ?? self.belard,
1799+ bocking: bocking ?? self.bocking,
1800+ brawlingly: brawlingly ?? self.brawlingly,
1801+ brookie: brookie ?? self.brookie,
1802+ bumboatman: bumboatman ?? self.bumboatman,
1803+ bystreet: bystreet ?? self.bystreet,
1804+ calaverite: calaverite ?? self.calaverite,
1805+ catallactic: catallactic ?? self.catallactic,
1806+ cemental: cemental ?? self.cemental,
1807+ chytridiaceae: chytridiaceae ?? self.chytridiaceae,
1808+ discordia: discordia ?? self.discordia,
1809+ endomyces: endomyces ?? self.endomyces,
1810+ epinephelidae: epinephelidae ?? self.epinephelidae,
1811+ eupatorium: eupatorium ?? self.eupatorium,
1812+ gryphosaurus: gryphosaurus ?? self.gryphosaurus,
1813+ koryak: koryak ?? self.koryak,
1814+ lavinia: lavinia ?? self.lavinia,
1815+ oskar: oskar ?? self.oskar,
1816+ rebecca: rebecca ?? self.rebecca,
1817+ rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei,
1818+ rigsmal: rigsmal ?? self.rigsmal,
1819+ ruellia: ruellia ?? self.ruellia,
1820+ school: school ?? self.school,
1821+ shakespearolater: shakespearolater ?? self.shakespearolater,
1822+ svan: svan ?? self.svan,
1823+ wayao: wayao ?? self.wayao
1824+ )
1825+ }
1826+
1827+ func jsonData() throws -> Data {
1828+ return try TopLevel.newJSONEncoder().encode(self)
1829+ }
1830+
1831+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1832+ return String(data: try self.jsonData(), encoding: encoding)
1833+ }
1834+}
1835+
1836+extension TopLevel.AnsarieClass {
1837+ init(data: Data) throws {
1838+ self = try TopLevel.newJSONDecoder().decode(TopLevel.AnsarieClass.self, from: data)
1839+ }
1840+
1841+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1842+ guard let data = json.data(using: encoding) else {
1843+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1844+ }
1845+ try self.init(data: data)
1846+ }
1847+
1848+ init(fromURL url: URL) throws {
1849+ try self.init(data: try Data(contentsOf: url))
1850+ }
1851+
1852+ func with(
1853+ accension: JSONNull?? = nil,
1854+ alida: JSONNull?? = nil,
1855+ asteria: JSONNull?? = nil,
1856+ beriberic: JSONNull?? = nil,
1857+ edgebone: JSONNull?? = nil,
1858+ gastrodialysis: JSONNull?? = nil,
1859+ geographic: JSONNull?? = nil,
1860+ ictonyx: JSONNull?? = nil,
1861+ metrocele: JSONNull?? = nil,
1862+ misgraft: JSONNull?? = nil,
1863+ monteith: JSONNull?? = nil,
1864+ notcher: JSONNull?? = nil,
1865+ prorestriction: JSONNull?? = nil,
1866+ ramist: JSONNull?? = nil,
1867+ throatlet: JSONNull?? = nil,
1868+ unfair: JSONNull?? = nil,
1869+ unsynonymous: JSONNull?? = nil,
1870+ water: JSONNull?? = nil,
1871+ zestfully: JSONNull?? = nil,
1872+ zincic: JSONNull?? = nil
1873+ ) -> TopLevel.AnsarieClass {
1874+ return TopLevel.AnsarieClass(
1875+ accension: accension ?? self.accension,
1876+ alida: alida ?? self.alida,
1877+ asteria: asteria ?? self.asteria,
1878+ beriberic: beriberic ?? self.beriberic,
1879+ edgebone: edgebone ?? self.edgebone,
1880+ gastrodialysis: gastrodialysis ?? self.gastrodialysis,
1881+ geographic: geographic ?? self.geographic,
1882+ ictonyx: ictonyx ?? self.ictonyx,
1883+ metrocele: metrocele ?? self.metrocele,
1884+ misgraft: misgraft ?? self.misgraft,
1885+ monteith: monteith ?? self.monteith,
1886+ notcher: notcher ?? self.notcher,
1887+ prorestriction: prorestriction ?? self.prorestriction,
1888+ ramist: ramist ?? self.ramist,
1889+ throatlet: throatlet ?? self.throatlet,
1890+ unfair: unfair ?? self.unfair,
1891+ unsynonymous: unsynonymous ?? self.unsynonymous,
1892+ water: water ?? self.water,
1893+ zestfully: zestfully ?? self.zestfully,
1894+ zincic: zincic ?? self.zincic
1895+ )
1896+ }
1897+
1898+ func jsonData() throws -> Data {
1899+ return try TopLevel.newJSONEncoder().encode(self)
1900+ }
1901+
1902+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1903+ return String(data: try self.jsonData(), encoding: encoding)
1904+ }
1905+}
1906+
1907+extension TopLevel.ChytridiaceaeClass {
1908+ init(data: Data) throws {
1909+ self = try TopLevel.newJSONDecoder().decode(TopLevel.ChytridiaceaeClass.self, from: data)
1910+ }
1911+
1912+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1913+ guard let data = json.data(using: encoding) else {
1914+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1915+ }
1916+ try self.init(data: data)
1917+ }
1918+
1919+ init(fromURL url: URL) throws {
1920+ try self.init(data: try Data(contentsOf: url))
1921+ }
1922+
1923+ func with(
1924+ batidaceae: JSONNull?? = nil,
1925+ brechites: JSONNull?? = nil,
1926+ codespairer: JSONNull?? = nil,
1927+ emery: JSONNull?? = nil,
1928+ enervative: JSONNull?? = nil,
1929+ excriminate: JSONNull?? = nil,
1930+ goshenite: JSONNull?? = nil,
1931+ grime: JSONNull?? = nil,
1932+ gritten: JSONNull?? = nil,
1933+ hectorly: JSONNull?? = nil,
1934+ intermediation: JSONNull?? = nil,
1935+ meeterly: JSONNull?? = nil,
1936+ narraganset: JSONNull?? = nil,
1937+ onymatic: JSONNull?? = nil,
1938+ paddlecock: JSONNull?? = nil,
1939+ thana: JSONNull?? = nil,
1940+ thornily: JSONNull?? = nil,
1941+ uckia: JSONNull?? = nil,
1942+ unmettle: JSONNull?? = nil,
1943+ vorticellid: JSONNull?? = nil
1944+ ) -> TopLevel.ChytridiaceaeClass {
1945+ return TopLevel.ChytridiaceaeClass(
1946+ batidaceae: batidaceae ?? self.batidaceae,
1947+ brechites: brechites ?? self.brechites,
1948+ codespairer: codespairer ?? self.codespairer,
1949+ emery: emery ?? self.emery,
1950+ enervative: enervative ?? self.enervative,
1951+ excriminate: excriminate ?? self.excriminate,
1952+ goshenite: goshenite ?? self.goshenite,
1953+ grime: grime ?? self.grime,
1954+ gritten: gritten ?? self.gritten,
1955+ hectorly: hectorly ?? self.hectorly,
1956+ intermediation: intermediation ?? self.intermediation,
1957+ meeterly: meeterly ?? self.meeterly,
1958+ narraganset: narraganset ?? self.narraganset,
1959+ onymatic: onymatic ?? self.onymatic,
1960+ paddlecock: paddlecock ?? self.paddlecock,
1961+ thana: thana ?? self.thana,
1962+ thornily: thornily ?? self.thornily,
1963+ uckia: uckia ?? self.uckia,
1964+ unmettle: unmettle ?? self.unmettle,
1965+ vorticellid: vorticellid ?? self.vorticellid
1966+ )
1967+ }
1968+
1969+ func jsonData() throws -> Data {
1970+ return try TopLevel.newJSONEncoder().encode(self)
1971+ }
1972+
1973+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
1974+ return String(data: try self.jsonData(), encoding: encoding)
1975+ }
1976+}
1977+
1978+extension TopLevel.DiscordiaClass {
1979+ init(data: Data) throws {
1980+ self = try TopLevel.newJSONDecoder().decode(TopLevel.DiscordiaClass.self, from: data)
1981+ }
1982+
1983+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1984+ guard let data = json.data(using: encoding) else {
1985+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1986+ }
1987+ try self.init(data: data)
1988+ }
1989+
1990+ init(fromURL url: URL) throws {
1991+ try self.init(data: try Data(contentsOf: url))
1992+ }
1993+
1994+ func with(
1995+ altaic: Int?? = nil,
1996+ amoristic: Int?? = nil,
1997+ blennophthalmia: Int?? = nil,
1998+ catharticalness: Double?? = nil,
1999+ chirotherium: Int?? = nil,
2000+ disciplinability: Int?? = nil,
2001+ disdiapason: String?? = nil,
2002+ goofer: Int?? = nil,
2003+ homocerc: Bool?? = nil,
2004+ laryngograph: Int?? = nil,
2005+ leucitis: Int?? = nil,
2006+ lymphocyst: Int?? = nil,
2007+ microcosmology: Int?? = nil,
2008+ nauseation: Int?? = nil,
2009+ nonbookish: JSONNull?? = nil,
2010+ patarin: Int?? = nil,
2011+ preliberal: Int?? = nil,
2012+ prettifier: Int?? = nil,
2013+ rangework: Int?? = nil,
2014+ redient: Int?? = nil,
2015+ subfusiform: Int?? = nil,
2016+ suicidical: Int?? = nil,
2017+ swow: Int?? = nil,
2018+ wastrel: Int?? = nil,
2019+ wingle: Int?? = nil
2020+ ) -> TopLevel.DiscordiaClass {
2021+ return TopLevel.DiscordiaClass(
2022+ altaic: altaic ?? self.altaic,
2023+ amoristic: amoristic ?? self.amoristic,
2024+ blennophthalmia: blennophthalmia ?? self.blennophthalmia,
2025+ catharticalness: catharticalness ?? self.catharticalness,
2026+ chirotherium: chirotherium ?? self.chirotherium,
2027+ disciplinability: disciplinability ?? self.disciplinability,
2028+ disdiapason: disdiapason ?? self.disdiapason,
2029+ goofer: goofer ?? self.goofer,
2030+ homocerc: homocerc ?? self.homocerc,
2031+ laryngograph: laryngograph ?? self.laryngograph,
2032+ leucitis: leucitis ?? self.leucitis,
2033+ lymphocyst: lymphocyst ?? self.lymphocyst,
2034+ microcosmology: microcosmology ?? self.microcosmology,
2035+ nauseation: nauseation ?? self.nauseation,
2036+ nonbookish: nonbookish ?? self.nonbookish,
2037+ patarin: patarin ?? self.patarin,
2038+ preliberal: preliberal ?? self.preliberal,
2039+ prettifier: prettifier ?? self.prettifier,
2040+ rangework: rangework ?? self.rangework,
2041+ redient: redient ?? self.redient,
2042+ subfusiform: subfusiform ?? self.subfusiform,
2043+ suicidical: suicidical ?? self.suicidical,
2044+ swow: swow ?? self.swow,
2045+ wastrel: wastrel ?? self.wastrel,
2046+ wingle: wingle ?? self.wingle
2047+ )
2048+ }
2049+
2050+ func jsonData() throws -> Data {
2051+ return try TopLevel.newJSONEncoder().encode(self)
2052+ }
2053+
2054+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2055+ return String(data: try self.jsonData(), encoding: encoding)
2056+ }
2057+}
2058+
2059+extension TopLevel.GryphosaurusClass {
2060+ init(data: Data) throws {
2061+ self = try TopLevel.newJSONDecoder().decode(TopLevel.GryphosaurusClass.self, from: data)
2062+ }
2063+
2064+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2065+ guard let data = json.data(using: encoding) else {
2066+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2067+ }
2068+ try self.init(data: data)
2069+ }
2070+
2071+ init(fromURL url: URL) throws {
2072+ try self.init(data: try Data(contentsOf: url))
2073+ }
2074+
2075+ func with(
2076+ amissibility: JSONNull?? = nil,
2077+ burushaski: JSONNull?? = nil,
2078+ citronin: JSONNull?? = nil,
2079+ coplaintiff: JSONNull?? = nil,
2080+ disquisitionary: JSONNull?? = nil,
2081+ enoplan: JSONNull?? = nil,
2082+ faintness: JSONNull?? = nil,
2083+ hebetomy: JSONNull?? = nil,
2084+ islandry: JSONNull?? = nil,
2085+ lameduck: JSONNull?? = nil,
2086+ overbattle: JSONNull?? = nil,
2087+ overinterested: JSONNull?? = nil,
2088+ phrenologic: JSONNull?? = nil,
2089+ rainband: JSONNull?? = nil,
2090+ shiningly: JSONNull?? = nil,
2091+ stamineous: JSONNull?? = nil,
2092+ subscapularis: JSONNull?? = nil,
2093+ tahami: JSONNull?? = nil,
2094+ undaubed: JSONNull?? = nil,
2095+ underntime: JSONNull?? = nil
2096+ ) -> TopLevel.GryphosaurusClass {
2097+ return TopLevel.GryphosaurusClass(
2098+ amissibility: amissibility ?? self.amissibility,
2099+ burushaski: burushaski ?? self.burushaski,
2100+ citronin: citronin ?? self.citronin,
2101+ coplaintiff: coplaintiff ?? self.coplaintiff,
2102+ disquisitionary: disquisitionary ?? self.disquisitionary,
2103+ enoplan: enoplan ?? self.enoplan,
2104+ faintness: faintness ?? self.faintness,
2105+ hebetomy: hebetomy ?? self.hebetomy,
2106+ islandry: islandry ?? self.islandry,
2107+ lameduck: lameduck ?? self.lameduck,
2108+ overbattle: overbattle ?? self.overbattle,
2109+ overinterested: overinterested ?? self.overinterested,
2110+ phrenologic: phrenologic ?? self.phrenologic,
2111+ rainband: rainband ?? self.rainband,
2112+ shiningly: shiningly ?? self.shiningly,
2113+ stamineous: stamineous ?? self.stamineous,
2114+ subscapularis: subscapularis ?? self.subscapularis,
2115+ tahami: tahami ?? self.tahami,
2116+ undaubed: undaubed ?? self.undaubed,
2117+ underntime: underntime ?? self.underntime
2118+ )
2119+ }
2120+
2121+ func jsonData() throws -> Data {
2122+ return try TopLevel.newJSONEncoder().encode(self)
2123+ }
2124+
2125+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2126+ return String(data: try self.jsonData(), encoding: encoding)
2127+ }
2128+}
2129+
2130+extension TopLevel.LaviniaClass {
2131+ init(data: Data) throws {
2132+ self = try TopLevel.newJSONDecoder().decode(TopLevel.LaviniaClass.self, from: data)
2133+ }
2134+
2135+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2136+ guard let data = json.data(using: encoding) else {
2137+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2138+ }
2139+ try self.init(data: data)
2140+ }
2141+
2142+ init(fromURL url: URL) throws {
2143+ try self.init(data: try Data(contentsOf: url))
2144+ }
2145+
2146+ func with(
2147+ agitable: Int?? = nil,
2148+ asininity: Int?? = nil,
2149+ benefiter: Int?? = nil,
2150+ bronzelike: Int?? = nil,
2151+ catharticalness: Double?? = nil,
2152+ chirotherium: Int?? = nil,
2153+ cholesteatomatous: Int?? = nil,
2154+ deprivement: Int?? = nil,
2155+ disdiapason: String?? = nil,
2156+ flippantness: Int?? = nil,
2157+ fogproof: Int?? = nil,
2158+ homocerc: Bool?? = nil,
2159+ merrymeeting: Int?? = nil,
2160+ nonbookish: JSONNull?? = nil,
2161+ overcareful: Int?? = nil,
2162+ panaris: Int?? = nil,
2163+ preacceptance: Int?? = nil,
2164+ quinoxaline: Int?? = nil,
2165+ sig: Int?? = nil,
2166+ superconfusion: Int?? = nil,
2167+ tacana: Int?? = nil,
2168+ tillotter: Int?? = nil,
2169+ tranquillize: Int?? = nil,
2170+ unquestionable: Int?? = nil,
2171+ uproute: Int?? = nil
2172+ ) -> TopLevel.LaviniaClass {
2173+ return TopLevel.LaviniaClass(
2174+ agitable: agitable ?? self.agitable,
2175+ asininity: asininity ?? self.asininity,
2176+ benefiter: benefiter ?? self.benefiter,
2177+ bronzelike: bronzelike ?? self.bronzelike,
2178+ catharticalness: catharticalness ?? self.catharticalness,
2179+ chirotherium: chirotherium ?? self.chirotherium,
2180+ cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous,
2181+ deprivement: deprivement ?? self.deprivement,
2182+ disdiapason: disdiapason ?? self.disdiapason,
2183+ flippantness: flippantness ?? self.flippantness,
2184+ fogproof: fogproof ?? self.fogproof,
2185+ homocerc: homocerc ?? self.homocerc,
2186+ merrymeeting: merrymeeting ?? self.merrymeeting,
2187+ nonbookish: nonbookish ?? self.nonbookish,
2188+ overcareful: overcareful ?? self.overcareful,
2189+ panaris: panaris ?? self.panaris,
2190+ preacceptance: preacceptance ?? self.preacceptance,
2191+ quinoxaline: quinoxaline ?? self.quinoxaline,
2192+ sig: sig ?? self.sig,
2193+ superconfusion: superconfusion ?? self.superconfusion,
2194+ tacana: tacana ?? self.tacana,
2195+ tillotter: tillotter ?? self.tillotter,
2196+ tranquillize: tranquillize ?? self.tranquillize,
2197+ unquestionable: unquestionable ?? self.unquestionable,
2198+ uproute: uproute ?? self.uproute
2199+ )
2200+ }
2201+
2202+ func jsonData() throws -> Data {
2203+ return try TopLevel.newJSONEncoder().encode(self)
2204+ }
2205+
2206+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2207+ return String(data: try self.jsonData(), encoding: encoding)
2208+ }
2209+}
2210+
2211+extension TopLevel.OskarClass {
2212+ init(data: Data) throws {
2213+ self = try TopLevel.newJSONDecoder().decode(TopLevel.OskarClass.self, from: data)
2214+ }
2215+
2216+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2217+ guard let data = json.data(using: encoding) else {
2218+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2219+ }
2220+ try self.init(data: data)
2221+ }
2222+
2223+ init(fromURL url: URL) throws {
2224+ try self.init(data: try Data(contentsOf: url))
2225+ }
2226+
2227+ func with(
2228+ acrobates: JSONNull?? = nil,
2229+ beanshooter: JSONNull?? = nil,
2230+ bearhound: JSONNull?? = nil,
2231+ cayuga: JSONNull?? = nil,
2232+ guarneri: JSONNull?? = nil,
2233+ hypochondriacism: JSONNull?? = nil,
2234+ indication: JSONNull?? = nil,
2235+ jaculative: JSONNull?? = nil,
2236+ nagana: JSONNull?? = nil,
2237+ netherlandish: JSONNull?? = nil,
2238+ noctivagous: JSONNull?? = nil,
2239+ nonphysiological: JSONNull?? = nil,
2240+ praxis: JSONNull?? = nil,
2241+ provision: JSONNull?? = nil,
2242+ subterhuman: JSONNull?? = nil,
2243+ sunlit: JSONNull?? = nil,
2244+ syncraniate: JSONNull?? = nil,
2245+ teachment: JSONNull?? = nil,
2246+ unmutinous: JSONNull?? = nil,
2247+ unstoppable: JSONNull?? = nil
2248+ ) -> TopLevel.OskarClass {
2249+ return TopLevel.OskarClass(
2250+ acrobates: acrobates ?? self.acrobates,
2251+ beanshooter: beanshooter ?? self.beanshooter,
2252+ bearhound: bearhound ?? self.bearhound,
2253+ cayuga: cayuga ?? self.cayuga,
2254+ guarneri: guarneri ?? self.guarneri,
2255+ hypochondriacism: hypochondriacism ?? self.hypochondriacism,
2256+ indication: indication ?? self.indication,
2257+ jaculative: jaculative ?? self.jaculative,
2258+ nagana: nagana ?? self.nagana,
2259+ netherlandish: netherlandish ?? self.netherlandish,
2260+ noctivagous: noctivagous ?? self.noctivagous,
2261+ nonphysiological: nonphysiological ?? self.nonphysiological,
2262+ praxis: praxis ?? self.praxis,
2263+ provision: provision ?? self.provision,
2264+ subterhuman: subterhuman ?? self.subterhuman,
2265+ sunlit: sunlit ?? self.sunlit,
2266+ syncraniate: syncraniate ?? self.syncraniate,
2267+ teachment: teachment ?? self.teachment,
2268+ unmutinous: unmutinous ?? self.unmutinous,
2269+ unstoppable: unstoppable ?? self.unstoppable
2270+ )
2271+ }
2272+
2273+ func jsonData() throws -> Data {
2274+ return try TopLevel.newJSONEncoder().encode(self)
2275+ }
2276+
2277+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2278+ return String(data: try self.jsonData(), encoding: encoding)
2279+ }
2280+}
2281+
2282+extension TopLevel.Rebecca {
2283+ init(data: Data) throws {
2284+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Rebecca.self, from: data)
2285+ }
2286+
2287+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2288+ guard let data = json.data(using: encoding) else {
2289+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2290+ }
2291+ try self.init(data: data)
2292+ }
2293+
2294+ init(fromURL url: URL) throws {
2295+ try self.init(data: try Data(contentsOf: url))
2296+ }
2297+
2298+ func with(
2299+ catharticalness: Double? = nil,
2300+ chirotherium: Int? = nil,
2301+ disdiapason: String? = nil,
2302+ homocerc: Bool? = nil,
2303+ nonbookish: JSONNull?? = nil
2304+ ) -> TopLevel.Rebecca {
2305+ return TopLevel.Rebecca(
2306+ catharticalness: catharticalness ?? self.catharticalness,
2307+ chirotherium: chirotherium ?? self.chirotherium,
2308+ disdiapason: disdiapason ?? self.disdiapason,
2309+ homocerc: homocerc ?? self.homocerc,
2310+ nonbookish: nonbookish ?? self.nonbookish
2311+ )
2312+ }
2313+
2314+ func jsonData() throws -> Data {
2315+ return try TopLevel.newJSONEncoder().encode(self)
2316+ }
2317+
2318+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2319+ return String(data: try self.jsonData(), encoding: encoding)
2320+ }
2321+}
2322+
2323+extension TopLevel.AlleviateClass {
2324+ init(data: Data) throws {
2325+ self = try TopLevel.newJSONDecoder().decode(TopLevel.AlleviateClass.self, from: data)
2326+ }
2327+
2328+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2329+ guard let data = json.data(using: encoding) else {
2330+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2331+ }
2332+ try self.init(data: data)
2333+ }
2334+
2335+ init(fromURL url: URL) throws {
2336+ try self.init(data: try Data(contentsOf: url))
2337+ }
2338+
2339+ func with(
2340+ apriori: JSONNull?? = nil,
2341+ beggarer: JSONNull?? = nil,
2342+ brokenheartedly: JSONNull?? = nil,
2343+ debilitation: JSONNull?? = nil,
2344+ frike: JSONNull?? = nil,
2345+ gastrolith: JSONNull?? = nil,
2346+ hulsean: JSONNull?? = nil,
2347+ orthocentric: JSONNull?? = nil,
2348+ petaly: JSONNull?? = nil,
2349+ probudgeting: JSONNull?? = nil,
2350+ reacquire: JSONNull?? = nil,
2351+ scow: JSONNull?? = nil,
2352+ shutoff: JSONNull?? = nil,
2353+ subcontiguous: JSONNull?? = nil,
2354+ suffumigate: JSONNull?? = nil,
2355+ transformable: JSONNull?? = nil,
2356+ uncoroneted: JSONNull?? = nil,
2357+ unparking: JSONNull?? = nil,
2358+ unvarnishedness: JSONNull?? = nil,
2359+ wherewithal: JSONNull?? = nil
2360+ ) -> TopLevel.AlleviateClass {
2361+ return TopLevel.AlleviateClass(
2362+ apriori: apriori ?? self.apriori,
2363+ beggarer: beggarer ?? self.beggarer,
2364+ brokenheartedly: brokenheartedly ?? self.brokenheartedly,
2365+ debilitation: debilitation ?? self.debilitation,
2366+ frike: frike ?? self.frike,
2367+ gastrolith: gastrolith ?? self.gastrolith,
2368+ hulsean: hulsean ?? self.hulsean,
2369+ orthocentric: orthocentric ?? self.orthocentric,
2370+ petaly: petaly ?? self.petaly,
2371+ probudgeting: probudgeting ?? self.probudgeting,
2372+ reacquire: reacquire ?? self.reacquire,
2373+ scow: scow ?? self.scow,
2374+ shutoff: shutoff ?? self.shutoff,
2375+ subcontiguous: subcontiguous ?? self.subcontiguous,
2376+ suffumigate: suffumigate ?? self.suffumigate,
2377+ transformable: transformable ?? self.transformable,
2378+ uncoroneted: uncoroneted ?? self.uncoroneted,
2379+ unparking: unparking ?? self.unparking,
2380+ unvarnishedness: unvarnishedness ?? self.unvarnishedness,
2381+ wherewithal: wherewithal ?? self.wherewithal
2382+ )
2383+ }
2384+
2385+ func jsonData() throws -> Data {
2386+ return try TopLevel.newJSONEncoder().encode(self)
2387+ }
2388+
2389+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2390+ return String(data: try self.jsonData(), encoding: encoding)
2391+ }
2392+}
2393+
2394+extension TopLevel.Amphithyron {
2395+ init(data: Data) throws {
2396+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Amphithyron.self, from: data)
2397+ }
2398+
2399+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2400+ guard let data = json.data(using: encoding) else {
2401+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2402+ }
2403+ try self.init(data: data)
2404+ }
2405+
2406+ init(fromURL url: URL) throws {
2407+ try self.init(data: try Data(contentsOf: url))
2408+ }
2409+
2410+ func with(
2411+ akroasis: Int?? = nil,
2412+ antiphonical: Int?? = nil,
2413+ basebred: Int?? = nil,
2414+ catharticalness: Double?? = nil,
2415+ chirotherium: Int?? = nil,
2416+ conductometric: Int?? = nil,
2417+ disdiapason: String?? = nil,
2418+ ensilation: Int?? = nil,
2419+ eyebolt: Int?? = nil,
2420+ fistulated: Int?? = nil,
2421+ heteropod: Int?? = nil,
2422+ homocerc: Bool?? = nil,
2423+ juniperus: Int?? = nil,
2424+ labyrinthically: Int?? = nil,
2425+ martyrization: Int?? = nil,
2426+ mispolicy: Int?? = nil,
2427+ multipara: Int?? = nil,
2428+ nazirite: Int?? = nil,
2429+ nonbookish: JSONNull?? = nil,
2430+ possessorial: Int?? = nil,
2431+ shamed: Int?? = nil,
2432+ shelfworn: Int?? = nil,
2433+ stagnum: Int?? = nil,
2434+ those: Int?? = nil,
2435+ undecimal: Int?? = nil
2436+ ) -> TopLevel.Amphithyron {
2437+ return TopLevel.Amphithyron(
2438+ akroasis: akroasis ?? self.akroasis,
2439+ antiphonical: antiphonical ?? self.antiphonical,
2440+ basebred: basebred ?? self.basebred,
2441+ catharticalness: catharticalness ?? self.catharticalness,
2442+ chirotherium: chirotherium ?? self.chirotherium,
2443+ conductometric: conductometric ?? self.conductometric,
2444+ disdiapason: disdiapason ?? self.disdiapason,
2445+ ensilation: ensilation ?? self.ensilation,
2446+ eyebolt: eyebolt ?? self.eyebolt,
2447+ fistulated: fistulated ?? self.fistulated,
2448+ heteropod: heteropod ?? self.heteropod,
2449+ homocerc: homocerc ?? self.homocerc,
2450+ juniperus: juniperus ?? self.juniperus,
2451+ labyrinthically: labyrinthically ?? self.labyrinthically,
2452+ martyrization: martyrization ?? self.martyrization,
2453+ mispolicy: mispolicy ?? self.mispolicy,
2454+ multipara: multipara ?? self.multipara,
2455+ nazirite: nazirite ?? self.nazirite,
2456+ nonbookish: nonbookish ?? self.nonbookish,
2457+ possessorial: possessorial ?? self.possessorial,
2458+ shamed: shamed ?? self.shamed,
2459+ shelfworn: shelfworn ?? self.shelfworn,
2460+ stagnum: stagnum ?? self.stagnum,
2461+ those: those ?? self.those,
2462+ undecimal: undecimal ?? self.undecimal
2463+ )
2464+ }
2465+
2466+ func jsonData() throws -> Data {
2467+ return try TopLevel.newJSONEncoder().encode(self)
2468+ }
2469+
2470+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2471+ return String(data: try self.jsonData(), encoding: encoding)
2472+ }
2473+}
2474+
2475+extension TopLevel.AnkeeClass {
2476+ init(data: Data) throws {
2477+ self = try TopLevel.newJSONDecoder().decode(TopLevel.AnkeeClass.self, from: data)
2478+ }
2479+
2480+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2481+ guard let data = json.data(using: encoding) else {
2482+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2483+ }
2484+ try self.init(data: data)
2485+ }
2486+
2487+ init(fromURL url: URL) throws {
2488+ try self.init(data: try Data(contentsOf: url))
2489+ }
2490+
2491+ func with(
2492+ anomoean: JSONNull?? = nil,
2493+ barleyhood: JSONNull?? = nil,
2494+ befriender: JSONNull?? = nil,
2495+ brutishness: JSONNull?? = nil,
2496+ cephalalgy: JSONNull?? = nil,
2497+ cirurgian: JSONNull?? = nil,
2498+ conventionally: JSONNull?? = nil,
2499+ jackshay: JSONNull?? = nil,
2500+ milammeter: JSONNull?? = nil,
2501+ naja: JSONNull?? = nil,
2502+ ombrological: JSONNull?? = nil,
2503+ phonasthenia: JSONNull?? = nil,
2504+ retrievableness: JSONNull?? = nil,
2505+ snakily: JSONNull?? = nil,
2506+ swot: JSONNull?? = nil,
2507+ tartlet: JSONNull?? = nil,
2508+ thiofuran: JSONNull?? = nil,
2509+ tracheophone: JSONNull?? = nil,
2510+ tuglike: JSONNull?? = nil,
2511+ unscratchingly: JSONNull?? = nil
2512+ ) -> TopLevel.AnkeeClass {
2513+ return TopLevel.AnkeeClass(
2514+ anomoean: anomoean ?? self.anomoean,
2515+ barleyhood: barleyhood ?? self.barleyhood,
2516+ befriender: befriender ?? self.befriender,
2517+ brutishness: brutishness ?? self.brutishness,
2518+ cephalalgy: cephalalgy ?? self.cephalalgy,
2519+ cirurgian: cirurgian ?? self.cirurgian,
2520+ conventionally: conventionally ?? self.conventionally,
2521+ jackshay: jackshay ?? self.jackshay,
2522+ milammeter: milammeter ?? self.milammeter,
2523+ naja: naja ?? self.naja,
2524+ ombrological: ombrological ?? self.ombrological,
2525+ phonasthenia: phonasthenia ?? self.phonasthenia,
2526+ retrievableness: retrievableness ?? self.retrievableness,
2527+ snakily: snakily ?? self.snakily,
2528+ swot: swot ?? self.swot,
2529+ tartlet: tartlet ?? self.tartlet,
2530+ thiofuran: thiofuran ?? self.thiofuran,
2531+ tracheophone: tracheophone ?? self.tracheophone,
2532+ tuglike: tuglike ?? self.tuglike,
2533+ unscratchingly: unscratchingly ?? self.unscratchingly
2534+ )
2535+ }
2536+
2537+ func jsonData() throws -> Data {
2538+ return try TopLevel.newJSONEncoder().encode(self)
2539+ }
2540+
2541+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2542+ return String(data: try self.jsonData(), encoding: encoding)
2543+ }
2544+}
2545+
2546+// MARK: - Encode/decode helpers
2547+
2548+class JSONNull: Codable, Hashable {
2549+
2550+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
2551+ return true
2552+ }
2553+
2554+ public func hash(into hasher: inout Hasher) {
2555+ hasher.combine(0)
2556+ }
2557+
2558+ public init() {}
2559+
2560+ public required init(from decoder: Decoder) throws {
2561+ let container = try decoder.singleValueContainer()
2562+ if !container.decodeNil() {
2563+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
2564+ }
2565+ }
2566+
2567+ public func encode(to encoder: Encoder) throws {
2568+ var container = encoder.singleValueContainer()
2569+ try container.encodeNil()
2570+ }
2571+}
Test case

test/inputs/json/priority/combinations3.json

1 generated file · +3,094 −0
Aswiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+3,094 −0
@@ -0,0 +1,3094 @@
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+ // MARK: Helper functions for creating encoders and decoders
1893+ static func newJSONDecoder() -> JSONDecoder {
1894+ let decoder = JSONDecoder()
1895+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
1896+ let container = try decoder.singleValueContainer()
1897+ let dateStr = try container.decode(String.self)
1898+
1899+ let formatter = DateFormatter()
1900+ formatter.calendar = Calendar(identifier: .iso8601)
1901+ formatter.locale = Locale(identifier: "en_US_POSIX")
1902+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
1903+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
1904+ if let date = formatter.date(from: dateStr) {
1905+ return date
1906+ }
1907+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
1908+ if let date = formatter.date(from: dateStr) {
1909+ return date
1910+ }
1911+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
1912+ })
1913+ return decoder
1914+ }
1915+
1916+ static func newJSONEncoder() -> JSONEncoder {
1917+ let encoder = JSONEncoder()
1918+ let formatter = DateFormatter()
1919+ formatter.calendar = Calendar(identifier: .iso8601)
1920+ formatter.locale = Locale(identifier: "en_US_POSIX")
1921+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
1922+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
1923+ encoder.dateEncodingStrategy = .formatted(formatter)
1924+ return encoder
1925+ }
1926+}
1927+
1928+// MARK: TopLevel convenience initializers and mutators
1929+
1930+extension TopLevel {
1931+ init(data: Data) throws {
1932+ self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data)
1933+ }
1934+
1935+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
1936+ guard let data = json.data(using: encoding) else {
1937+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
1938+ }
1939+ try self.init(data: data)
1940+ }
1941+
1942+ init(fromURL url: URL) throws {
1943+ try self.init(data: try Data(contentsOf: url))
1944+ }
1945+
1946+ func with(
1947+ juror: [TopLevel.JurorElement]? = nil,
1948+ kongoni: [TopLevel.Kongoni]? = nil,
1949+ ladronism: [TopLevel.LadronismElement]? = nil,
1950+ landlubberly: [TopLevel.LandlubberlyElement]? = nil,
1951+ listener: [TopLevel.Listener]? = nil,
1952+ lupus: [TopLevel.LupusElement]? = nil,
1953+ maslin: [TopLevel.Maslin]? = nil,
1954+ monazite: [TopLevel.MonaziteElement]? = nil,
1955+ monoliteral: [TopLevel.Monoliteral]? = nil,
1956+ monotheistically: [TopLevel.MonotheisticallyElement]? = nil,
1957+ montage: [TopLevel.Montage]? = nil,
1958+ moralness: [TopLevel.Moralness]? = nil,
1959+ mowra: [TopLevel.MonaziteClass?]? = nil,
1960+ mulishly: [TopLevel.Mulishly]? = nil,
1961+ myoscope: [TopLevel.Myoscope]? = nil,
1962+ nach: [[Int?]?]? = nil,
1963+ neuromastic: [TopLevel.Neuromastic]? = nil,
1964+ noncontributing: [TopLevel.Noncontributing]? = nil,
1965+ nonnervous: [TopLevel.Nonnervous]? = nil,
1966+ nonvaluation: [TopLevel.Nonvaluation]? = nil,
1967+ occupationalist: [TopLevel.OccupationalistElement]? = nil,
1968+ outrival: [TopLevel.OutrivalElement]? = nil,
1969+ paleographically: [TopLevel.Paleographically]? = nil,
1970+ pamphletwise: [TopLevel.Pamphletwise]? = nil,
1971+ pediatrics: [TopLevel.Pediatric]? = nil,
1972+ perceptive: [Bool]? = nil,
1973+ piaculum: [TopLevel.PiaculumElement]? = nil,
1974+ piccadilly: [TopLevel.Piccadilly]? = nil,
1975+ piffler: [TopLevel.Piffler]? = nil,
1976+ pithful: [TopLevel.Pithful]? = nil,
1977+ placuntitis: [TopLevel.Placuntiti]? = nil,
1978+ plectopterous: [TopLevel.Plectopterous]? = nil,
1979+ pneumocele: [TopLevel.Pneumocele?]? = nil,
1980+ poliorcetic: [TopLevel.Poliorcetic]? = nil,
1981+ poormaster: [TopLevel.Poormaster]? = nil,
1982+ potwhisky: [TopLevel.PotwhiskyElement]? = nil,
1983+ practicalizer: [TopLevel.Practicalizer]? = nil,
1984+ prefreshman: [TopLevel.PrefreshmanElement]? = nil,
1985+ prehensility: [TopLevel.Prehensility]? = nil,
1986+ prevoidance: [TopLevel.Prevoidance]? = nil,
1987+ probant: [[String: Int?]]? = nil,
1988+ protext: [TopLevel.Protext]? = nil
1989+ ) -> TopLevel {
1990+ return TopLevel(
1991+ juror: juror ?? self.juror,
1992+ kongoni: kongoni ?? self.kongoni,
1993+ ladronism: ladronism ?? self.ladronism,
1994+ landlubberly: landlubberly ?? self.landlubberly,
1995+ listener: listener ?? self.listener,
1996+ lupus: lupus ?? self.lupus,
1997+ maslin: maslin ?? self.maslin,
1998+ monazite: monazite ?? self.monazite,
1999+ monoliteral: monoliteral ?? self.monoliteral,
2000+ monotheistically: monotheistically ?? self.monotheistically,
2001+ montage: montage ?? self.montage,
2002+ moralness: moralness ?? self.moralness,
2003+ mowra: mowra ?? self.mowra,
2004+ mulishly: mulishly ?? self.mulishly,
2005+ myoscope: myoscope ?? self.myoscope,
2006+ nach: nach ?? self.nach,
2007+ neuromastic: neuromastic ?? self.neuromastic,
2008+ noncontributing: noncontributing ?? self.noncontributing,
2009+ nonnervous: nonnervous ?? self.nonnervous,
2010+ nonvaluation: nonvaluation ?? self.nonvaluation,
2011+ occupationalist: occupationalist ?? self.occupationalist,
2012+ outrival: outrival ?? self.outrival,
2013+ paleographically: paleographically ?? self.paleographically,
2014+ pamphletwise: pamphletwise ?? self.pamphletwise,
2015+ pediatrics: pediatrics ?? self.pediatrics,
2016+ perceptive: perceptive ?? self.perceptive,
2017+ piaculum: piaculum ?? self.piaculum,
2018+ piccadilly: piccadilly ?? self.piccadilly,
2019+ piffler: piffler ?? self.piffler,
2020+ pithful: pithful ?? self.pithful,
2021+ placuntitis: placuntitis ?? self.placuntitis,
2022+ plectopterous: plectopterous ?? self.plectopterous,
2023+ pneumocele: pneumocele ?? self.pneumocele,
2024+ poliorcetic: poliorcetic ?? self.poliorcetic,
2025+ poormaster: poormaster ?? self.poormaster,
2026+ potwhisky: potwhisky ?? self.potwhisky,
2027+ practicalizer: practicalizer ?? self.practicalizer,
2028+ prefreshman: prefreshman ?? self.prefreshman,
2029+ prehensility: prehensility ?? self.prehensility,
2030+ prevoidance: prevoidance ?? self.prevoidance,
2031+ probant: probant ?? self.probant,
2032+ protext: protext ?? self.protext
2033+ )
2034+ }
2035+
2036+ func jsonData() throws -> Data {
2037+ return try TopLevel.newJSONEncoder().encode(self)
2038+ }
2039+
2040+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2041+ return String(data: try self.jsonData(), encoding: encoding)
2042+ }
2043+}
2044+
2045+extension TopLevel.JurorClass {
2046+ init(data: Data) throws {
2047+ self = try TopLevel.newJSONDecoder().decode(TopLevel.JurorClass.self, from: data)
2048+ }
2049+
2050+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2051+ guard let data = json.data(using: encoding) else {
2052+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2053+ }
2054+ try self.init(data: data)
2055+ }
2056+
2057+ init(fromURL url: URL) throws {
2058+ try self.init(data: try Data(contentsOf: url))
2059+ }
2060+
2061+ func with(
2062+ adipsy: JSONNull?? = nil,
2063+ auxiliator: JSONNull?? = nil,
2064+ benda: JSONNull?? = nil,
2065+ benjamin: JSONNull?? = nil,
2066+ brandling: JSONNull?? = nil,
2067+ epicurishly: JSONNull?? = nil,
2068+ eremochaetous: JSONNull?? = nil,
2069+ marten: JSONNull?? = nil,
2070+ monocline: JSONNull?? = nil,
2071+ olea: JSONNull?? = nil,
2072+ palgat: JSONNull?? = nil,
2073+ pennyworth: JSONNull?? = nil,
2074+ pioury: JSONNull?? = nil,
2075+ pragmatistic: JSONNull?? = nil,
2076+ stylelessness: JSONNull?? = nil,
2077+ systematical: JSONNull?? = nil,
2078+ thready: JSONNull?? = nil,
2079+ uncontemporary: JSONNull?? = nil,
2080+ uncouched: JSONNull?? = nil,
2081+ uninhabitedness: JSONNull?? = nil
2082+ ) -> TopLevel.JurorClass {
2083+ return TopLevel.JurorClass(
2084+ adipsy: adipsy ?? self.adipsy,
2085+ auxiliator: auxiliator ?? self.auxiliator,
2086+ benda: benda ?? self.benda,
2087+ benjamin: benjamin ?? self.benjamin,
2088+ brandling: brandling ?? self.brandling,
2089+ epicurishly: epicurishly ?? self.epicurishly,
2090+ eremochaetous: eremochaetous ?? self.eremochaetous,
2091+ marten: marten ?? self.marten,
2092+ monocline: monocline ?? self.monocline,
2093+ olea: olea ?? self.olea,
2094+ palgat: palgat ?? self.palgat,
2095+ pennyworth: pennyworth ?? self.pennyworth,
2096+ pioury: pioury ?? self.pioury,
2097+ pragmatistic: pragmatistic ?? self.pragmatistic,
2098+ stylelessness: stylelessness ?? self.stylelessness,
2099+ systematical: systematical ?? self.systematical,
2100+ thready: thready ?? self.thready,
2101+ uncontemporary: uncontemporary ?? self.uncontemporary,
2102+ uncouched: uncouched ?? self.uncouched,
2103+ uninhabitedness: uninhabitedness ?? self.uninhabitedness
2104+ )
2105+ }
2106+
2107+ func jsonData() throws -> Data {
2108+ return try TopLevel.newJSONEncoder().encode(self)
2109+ }
2110+
2111+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2112+ return String(data: try self.jsonData(), encoding: encoding)
2113+ }
2114+}
2115+
2116+extension TopLevel.LadronismClass {
2117+ init(data: Data) throws {
2118+ self = try TopLevel.newJSONDecoder().decode(TopLevel.LadronismClass.self, from: data)
2119+ }
2120+
2121+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2122+ guard let data = json.data(using: encoding) else {
2123+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2124+ }
2125+ try self.init(data: data)
2126+ }
2127+
2128+ init(fromURL url: URL) throws {
2129+ try self.init(data: try Data(contentsOf: url))
2130+ }
2131+
2132+ func with(
2133+ acclaimer: JSONNull?? = nil,
2134+ achree: JSONNull?? = nil,
2135+ base: JSONNull?? = nil,
2136+ conundrumize: JSONNull?? = nil,
2137+ degerminator: JSONNull?? = nil,
2138+ describable: JSONNull?? = nil,
2139+ exasperatedly: JSONNull?? = nil,
2140+ heroine: JSONNull?? = nil,
2141+ indazin: JSONNull?? = nil,
2142+ luteous: JSONNull?? = nil,
2143+ papular: JSONNull?? = nil,
2144+ pritch: JSONNull?? = nil,
2145+ prodenia: JSONNull?? = nil,
2146+ seege: JSONNull?? = nil,
2147+ shopgirl: JSONNull?? = nil,
2148+ tragedietta: JSONNull?? = nil,
2149+ unsparse: JSONNull?? = nil,
2150+ uplook: JSONNull?? = nil,
2151+ vermiformis: JSONNull?? = nil,
2152+ whafabout: JSONNull?? = nil
2153+ ) -> TopLevel.LadronismClass {
2154+ return TopLevel.LadronismClass(
2155+ acclaimer: acclaimer ?? self.acclaimer,
2156+ achree: achree ?? self.achree,
2157+ base: base ?? self.base,
2158+ conundrumize: conundrumize ?? self.conundrumize,
2159+ degerminator: degerminator ?? self.degerminator,
2160+ describable: describable ?? self.describable,
2161+ exasperatedly: exasperatedly ?? self.exasperatedly,
2162+ heroine: heroine ?? self.heroine,
2163+ indazin: indazin ?? self.indazin,
2164+ luteous: luteous ?? self.luteous,
2165+ papular: papular ?? self.papular,
2166+ pritch: pritch ?? self.pritch,
2167+ prodenia: prodenia ?? self.prodenia,
2168+ seege: seege ?? self.seege,
2169+ shopgirl: shopgirl ?? self.shopgirl,
2170+ tragedietta: tragedietta ?? self.tragedietta,
2171+ unsparse: unsparse ?? self.unsparse,
2172+ uplook: uplook ?? self.uplook,
2173+ vermiformis: vermiformis ?? self.vermiformis,
2174+ whafabout: whafabout ?? self.whafabout
2175+ )
2176+ }
2177+
2178+ func jsonData() throws -> Data {
2179+ return try TopLevel.newJSONEncoder().encode(self)
2180+ }
2181+
2182+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2183+ return String(data: try self.jsonData(), encoding: encoding)
2184+ }
2185+}
2186+
2187+extension TopLevel.LandlubberlyClass {
2188+ init(data: Data) throws {
2189+ self = try TopLevel.newJSONDecoder().decode(TopLevel.LandlubberlyClass.self, from: data)
2190+ }
2191+
2192+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2193+ guard let data = json.data(using: encoding) else {
2194+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2195+ }
2196+ try self.init(data: data)
2197+ }
2198+
2199+ init(fromURL url: URL) throws {
2200+ try self.init(data: try Data(contentsOf: url))
2201+ }
2202+
2203+ func with(
2204+ acropoleis: JSONNull?? = nil,
2205+ aminate: JSONNull?? = nil,
2206+ amyraldism: JSONNull?? = nil,
2207+ bipenniform: JSONNull?? = nil,
2208+ bugre: JSONNull?? = nil,
2209+ calycule: JSONNull?? = nil,
2210+ caoutchouc: JSONNull?? = nil,
2211+ disprover: JSONNull?? = nil,
2212+ fitroot: JSONNull?? = nil,
2213+ fulgently: JSONNull?? = nil,
2214+ kickup: JSONNull?? = nil,
2215+ laevoversion: JSONNull?? = nil,
2216+ moter: JSONNull?? = nil,
2217+ objectivity: JSONNull?? = nil,
2218+ posterity: JSONNull?? = nil,
2219+ postnuptial: JSONNull?? = nil,
2220+ precedentary: JSONNull?? = nil,
2221+ saddling: JSONNull?? = nil,
2222+ subcurrent: JSONNull?? = nil,
2223+ unrecriminative: JSONNull?? = nil
2224+ ) -> TopLevel.LandlubberlyClass {
2225+ return TopLevel.LandlubberlyClass(
2226+ acropoleis: acropoleis ?? self.acropoleis,
2227+ aminate: aminate ?? self.aminate,
2228+ amyraldism: amyraldism ?? self.amyraldism,
2229+ bipenniform: bipenniform ?? self.bipenniform,
2230+ bugre: bugre ?? self.bugre,
2231+ calycule: calycule ?? self.calycule,
2232+ caoutchouc: caoutchouc ?? self.caoutchouc,
2233+ disprover: disprover ?? self.disprover,
2234+ fitroot: fitroot ?? self.fitroot,
2235+ fulgently: fulgently ?? self.fulgently,
2236+ kickup: kickup ?? self.kickup,
2237+ laevoversion: laevoversion ?? self.laevoversion,
2238+ moter: moter ?? self.moter,
2239+ objectivity: objectivity ?? self.objectivity,
2240+ posterity: posterity ?? self.posterity,
2241+ postnuptial: postnuptial ?? self.postnuptial,
2242+ precedentary: precedentary ?? self.precedentary,
2243+ saddling: saddling ?? self.saddling,
2244+ subcurrent: subcurrent ?? self.subcurrent,
2245+ unrecriminative: unrecriminative ?? self.unrecriminative
2246+ )
2247+ }
2248+
2249+ func jsonData() throws -> Data {
2250+ return try TopLevel.newJSONEncoder().encode(self)
2251+ }
2252+
2253+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2254+ return String(data: try self.jsonData(), encoding: encoding)
2255+ }
2256+}
2257+
2258+extension TopLevel.LupusClass {
2259+ init(data: Data) throws {
2260+ self = try TopLevel.newJSONDecoder().decode(TopLevel.LupusClass.self, from: data)
2261+ }
2262+
2263+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2264+ guard let data = json.data(using: encoding) else {
2265+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2266+ }
2267+ try self.init(data: data)
2268+ }
2269+
2270+ init(fromURL url: URL) throws {
2271+ try self.init(data: try Data(contentsOf: url))
2272+ }
2273+
2274+ func with(
2275+ catharticalness: Double?? = nil,
2276+ chirotherium: Int?? = nil,
2277+ chlorioninae: Int?? = nil,
2278+ corvinae: Int?? = nil,
2279+ crassina: Int?? = nil,
2280+ disdiapason: String?? = nil,
2281+ exiguity: Int?? = nil,
2282+ farcist: Int?? = nil,
2283+ holographical: Int?? = nil,
2284+ homocerc: Bool?? = nil,
2285+ ichthyophagan: Int?? = nil,
2286+ implacable: Int?? = nil,
2287+ nonbookish: JSONNull?? = nil,
2288+ outshiner: Int?? = nil,
2289+ overweather: Int?? = nil,
2290+ protonegroid: Int?? = nil,
2291+ shallowish: Int?? = nil,
2292+ snoke: Int?? = nil,
2293+ snout: Int?? = nil,
2294+ surveillance: Int?? = nil,
2295+ threshingtime: Int?? = nil,
2296+ thysanocarpus: Int?? = nil,
2297+ unsignificantly: Int?? = nil,
2298+ unsnap: Int?? = nil,
2299+ vendible: Int?? = nil
2300+ ) -> TopLevel.LupusClass {
2301+ return TopLevel.LupusClass(
2302+ catharticalness: catharticalness ?? self.catharticalness,
2303+ chirotherium: chirotherium ?? self.chirotherium,
2304+ chlorioninae: chlorioninae ?? self.chlorioninae,
2305+ corvinae: corvinae ?? self.corvinae,
2306+ crassina: crassina ?? self.crassina,
2307+ disdiapason: disdiapason ?? self.disdiapason,
2308+ exiguity: exiguity ?? self.exiguity,
2309+ farcist: farcist ?? self.farcist,
2310+ holographical: holographical ?? self.holographical,
2311+ homocerc: homocerc ?? self.homocerc,
2312+ ichthyophagan: ichthyophagan ?? self.ichthyophagan,
2313+ implacable: implacable ?? self.implacable,
2314+ nonbookish: nonbookish ?? self.nonbookish,
2315+ outshiner: outshiner ?? self.outshiner,
2316+ overweather: overweather ?? self.overweather,
2317+ protonegroid: protonegroid ?? self.protonegroid,
2318+ shallowish: shallowish ?? self.shallowish,
2319+ snoke: snoke ?? self.snoke,
2320+ snout: snout ?? self.snout,
2321+ surveillance: surveillance ?? self.surveillance,
2322+ threshingtime: threshingtime ?? self.threshingtime,
2323+ thysanocarpus: thysanocarpus ?? self.thysanocarpus,
2324+ unsignificantly: unsignificantly ?? self.unsignificantly,
2325+ unsnap: unsnap ?? self.unsnap,
2326+ vendible: vendible ?? self.vendible
2327+ )
2328+ }
2329+
2330+ func jsonData() throws -> Data {
2331+ return try TopLevel.newJSONEncoder().encode(self)
2332+ }
2333+
2334+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2335+ return String(data: try self.jsonData(), encoding: encoding)
2336+ }
2337+}
2338+
2339+extension TopLevel.Maslin {
2340+ init(data: Data) throws {
2341+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Maslin.self, from: data)
2342+ }
2343+
2344+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2345+ guard let data = json.data(using: encoding) else {
2346+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2347+ }
2348+ try self.init(data: data)
2349+ }
2350+
2351+ init(fromURL url: URL) throws {
2352+ try self.init(data: try Data(contentsOf: url))
2353+ }
2354+
2355+ func with(
2356+ alicant: Int?? = nil,
2357+ antiatonement: JSONNull?? = nil,
2358+ anticorrosive: Int?? = nil,
2359+ aphidozer: JSONNull?? = nil,
2360+ bakuninist: JSONNull?? = nil,
2361+ be: Int?? = nil,
2362+ catharticalness: Double?? = nil,
2363+ chirotherium: Int?? = nil,
2364+ chub: Int?? = nil,
2365+ cuprosilicon: Int?? = nil,
2366+ curtailedly: Int?? = nil,
2367+ dellenite: Int?? = nil,
2368+ dimitry: Int?? = nil,
2369+ disdiapason: String?? = nil,
2370+ edifying: JSONNull?? = nil,
2371+ ethmoiditis: Int?? = nil,
2372+ gastralgy: JSONNull?? = nil,
2373+ goatherd: Int?? = nil,
2374+ hammerdress: Int?? = nil,
2375+ hangfire: JSONNull?? = nil,
2376+ homocerc: Bool?? = nil,
2377+ lacunosity: Int?? = nil,
2378+ longiloquence: JSONNull?? = nil,
2379+ mameliere: Int?? = nil,
2380+ motherless: JSONNull?? = nil,
2381+ nonbookish: JSONNull?? = nil,
2382+ noncorrodible: JSONNull?? = nil,
2383+ nonsensicality: JSONNull?? = nil,
2384+ oafishly: Int?? = nil,
2385+ pfund: JSONNull?? = nil,
2386+ preadvisory: JSONNull?? = nil,
2387+ retroflexed: JSONNull?? = nil,
2388+ saccharulmic: Int?? = nil,
2389+ scowlful: Int?? = nil,
2390+ secluded: JSONNull?? = nil,
2391+ slackage: JSONNull?? = nil,
2392+ sphaeridial: Int?? = nil,
2393+ spondulics: JSONNull?? = nil,
2394+ subsecive: Int?? = nil,
2395+ swellmobsman: JSONNull?? = nil,
2396+ trachyglossate: Int?? = nil,
2397+ trialogue: JSONNull?? = nil,
2398+ unassuaged: Int?? = nil,
2399+ ungross: JSONNull?? = nil,
2400+ unjudiciously: JSONNull?? = nil
2401+ ) -> TopLevel.Maslin {
2402+ return TopLevel.Maslin(
2403+ alicant: alicant ?? self.alicant,
2404+ antiatonement: antiatonement ?? self.antiatonement,
2405+ anticorrosive: anticorrosive ?? self.anticorrosive,
2406+ aphidozer: aphidozer ?? self.aphidozer,
2407+ bakuninist: bakuninist ?? self.bakuninist,
2408+ be: be ?? self.be,
2409+ catharticalness: catharticalness ?? self.catharticalness,
2410+ chirotherium: chirotherium ?? self.chirotherium,
2411+ chub: chub ?? self.chub,
2412+ cuprosilicon: cuprosilicon ?? self.cuprosilicon,
2413+ curtailedly: curtailedly ?? self.curtailedly,
2414+ dellenite: dellenite ?? self.dellenite,
2415+ dimitry: dimitry ?? self.dimitry,
2416+ disdiapason: disdiapason ?? self.disdiapason,
2417+ edifying: edifying ?? self.edifying,
2418+ ethmoiditis: ethmoiditis ?? self.ethmoiditis,
2419+ gastralgy: gastralgy ?? self.gastralgy,
2420+ goatherd: goatherd ?? self.goatherd,
2421+ hammerdress: hammerdress ?? self.hammerdress,
2422+ hangfire: hangfire ?? self.hangfire,
2423+ homocerc: homocerc ?? self.homocerc,
2424+ lacunosity: lacunosity ?? self.lacunosity,
2425+ longiloquence: longiloquence ?? self.longiloquence,
2426+ mameliere: mameliere ?? self.mameliere,
2427+ motherless: motherless ?? self.motherless,
2428+ nonbookish: nonbookish ?? self.nonbookish,
2429+ noncorrodible: noncorrodible ?? self.noncorrodible,
2430+ nonsensicality: nonsensicality ?? self.nonsensicality,
2431+ oafishly: oafishly ?? self.oafishly,
2432+ pfund: pfund ?? self.pfund,
2433+ preadvisory: preadvisory ?? self.preadvisory,
2434+ retroflexed: retroflexed ?? self.retroflexed,
2435+ saccharulmic: saccharulmic ?? self.saccharulmic,
2436+ scowlful: scowlful ?? self.scowlful,
2437+ secluded: secluded ?? self.secluded,
2438+ slackage: slackage ?? self.slackage,
2439+ sphaeridial: sphaeridial ?? self.sphaeridial,
2440+ spondulics: spondulics ?? self.spondulics,
2441+ subsecive: subsecive ?? self.subsecive,
2442+ swellmobsman: swellmobsman ?? self.swellmobsman,
2443+ trachyglossate: trachyglossate ?? self.trachyglossate,
2444+ trialogue: trialogue ?? self.trialogue,
2445+ unassuaged: unassuaged ?? self.unassuaged,
2446+ ungross: ungross ?? self.ungross,
2447+ unjudiciously: unjudiciously ?? self.unjudiciously
2448+ )
2449+ }
2450+
2451+ func jsonData() throws -> Data {
2452+ return try TopLevel.newJSONEncoder().encode(self)
2453+ }
2454+
2455+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2456+ return String(data: try self.jsonData(), encoding: encoding)
2457+ }
2458+}
2459+
2460+extension TopLevel.MonaziteClass {
2461+ init(data: Data) throws {
2462+ self = try TopLevel.newJSONDecoder().decode(TopLevel.MonaziteClass.self, from: data)
2463+ }
2464+
2465+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2466+ guard let data = json.data(using: encoding) else {
2467+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2468+ }
2469+ try self.init(data: data)
2470+ }
2471+
2472+ init(fromURL url: URL) throws {
2473+ try self.init(data: try Data(contentsOf: url))
2474+ }
2475+
2476+ func with(
2477+ catharticalness: Double? = nil,
2478+ chirotherium: Int? = nil,
2479+ disdiapason: String? = nil,
2480+ homocerc: Bool? = nil,
2481+ nonbookish: JSONNull?? = nil
2482+ ) -> TopLevel.MonaziteClass {
2483+ return TopLevel.MonaziteClass(
2484+ catharticalness: catharticalness ?? self.catharticalness,
2485+ chirotherium: chirotherium ?? self.chirotherium,
2486+ disdiapason: disdiapason ?? self.disdiapason,
2487+ homocerc: homocerc ?? self.homocerc,
2488+ nonbookish: nonbookish ?? self.nonbookish
2489+ )
2490+ }
2491+
2492+ func jsonData() throws -> Data {
2493+ return try TopLevel.newJSONEncoder().encode(self)
2494+ }
2495+
2496+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2497+ return String(data: try self.jsonData(), encoding: encoding)
2498+ }
2499+}
2500+
2501+extension TopLevel.MonotheisticallyClass {
2502+ init(data: Data) throws {
2503+ self = try TopLevel.newJSONDecoder().decode(TopLevel.MonotheisticallyClass.self, from: data)
2504+ }
2505+
2506+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2507+ guard let data = json.data(using: encoding) else {
2508+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2509+ }
2510+ try self.init(data: data)
2511+ }
2512+
2513+ init(fromURL url: URL) throws {
2514+ try self.init(data: try Data(contentsOf: url))
2515+ }
2516+
2517+ func with(
2518+ blaspheme: JSONNull?? = nil,
2519+ catharticalness: Double?? = nil,
2520+ celiosalpingectomy: JSONNull?? = nil,
2521+ chirotherium: Int?? = nil,
2522+ consummativeness: JSONNull?? = nil,
2523+ disdiapason: String?? = nil,
2524+ egestive: JSONNull?? = nil,
2525+ enchylema: JSONNull?? = nil,
2526+ gasconade: JSONNull?? = nil,
2527+ holidayer: JSONNull?? = nil,
2528+ homocerc: Bool?? = nil,
2529+ intuitionalism: JSONNull?? = nil,
2530+ lophiostomate: JSONNull?? = nil,
2531+ nonbookish: JSONNull?? = nil,
2532+ nonvolition: JSONNull?? = nil,
2533+ palatableness: JSONNull?? = nil,
2534+ pimpery: JSONNull?? = nil,
2535+ previolation: JSONNull?? = nil,
2536+ reconveyance: JSONNull?? = nil,
2537+ registership: JSONNull?? = nil,
2538+ rhyacolite: JSONNull?? = nil,
2539+ smithereens: JSONNull?? = nil,
2540+ superedification: JSONNull?? = nil,
2541+ trust: JSONNull?? = nil,
2542+ whitestone: JSONNull?? = nil
2543+ ) -> TopLevel.MonotheisticallyClass {
2544+ return TopLevel.MonotheisticallyClass(
2545+ blaspheme: blaspheme ?? self.blaspheme,
2546+ catharticalness: catharticalness ?? self.catharticalness,
2547+ celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy,
2548+ chirotherium: chirotherium ?? self.chirotherium,
2549+ consummativeness: consummativeness ?? self.consummativeness,
2550+ disdiapason: disdiapason ?? self.disdiapason,
2551+ egestive: egestive ?? self.egestive,
2552+ enchylema: enchylema ?? self.enchylema,
2553+ gasconade: gasconade ?? self.gasconade,
2554+ holidayer: holidayer ?? self.holidayer,
2555+ homocerc: homocerc ?? self.homocerc,
2556+ intuitionalism: intuitionalism ?? self.intuitionalism,
2557+ lophiostomate: lophiostomate ?? self.lophiostomate,
2558+ nonbookish: nonbookish ?? self.nonbookish,
2559+ nonvolition: nonvolition ?? self.nonvolition,
2560+ palatableness: palatableness ?? self.palatableness,
2561+ pimpery: pimpery ?? self.pimpery,
2562+ previolation: previolation ?? self.previolation,
2563+ reconveyance: reconveyance ?? self.reconveyance,
2564+ registership: registership ?? self.registership,
2565+ rhyacolite: rhyacolite ?? self.rhyacolite,
2566+ smithereens: smithereens ?? self.smithereens,
2567+ superedification: superedification ?? self.superedification,
2568+ trust: trust ?? self.trust,
2569+ whitestone: whitestone ?? self.whitestone
2570+ )
2571+ }
2572+
2573+ func jsonData() throws -> Data {
2574+ return try TopLevel.newJSONEncoder().encode(self)
2575+ }
2576+
2577+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2578+ return String(data: try self.jsonData(), encoding: encoding)
2579+ }
2580+}
2581+
2582+extension TopLevel.Noncontributing {
2583+ init(data: Data) throws {
2584+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Noncontributing.self, from: data)
2585+ }
2586+
2587+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2588+ guard let data = json.data(using: encoding) else {
2589+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2590+ }
2591+ try self.init(data: data)
2592+ }
2593+
2594+ init(fromURL url: URL) throws {
2595+ try self.init(data: try Data(contentsOf: url))
2596+ }
2597+
2598+ func with(
2599+ estevin: String? = nil,
2600+ jolterhead: Double? = nil,
2601+ sauternes: Int? = nil,
2602+ sparsely: Bool? = nil,
2603+ unrequested: JSONNull?? = nil
2604+ ) -> TopLevel.Noncontributing {
2605+ return TopLevel.Noncontributing(
2606+ estevin: estevin ?? self.estevin,
2607+ jolterhead: jolterhead ?? self.jolterhead,
2608+ sauternes: sauternes ?? self.sauternes,
2609+ sparsely: sparsely ?? self.sparsely,
2610+ unrequested: unrequested ?? self.unrequested
2611+ )
2612+ }
2613+
2614+ func jsonData() throws -> Data {
2615+ return try TopLevel.newJSONEncoder().encode(self)
2616+ }
2617+
2618+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2619+ return String(data: try self.jsonData(), encoding: encoding)
2620+ }
2621+}
2622+
2623+extension TopLevel.OccupationalistClass {
2624+ init(data: Data) throws {
2625+ self = try TopLevel.newJSONDecoder().decode(TopLevel.OccupationalistClass.self, from: data)
2626+ }
2627+
2628+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2629+ guard let data = json.data(using: encoding) else {
2630+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2631+ }
2632+ try self.init(data: data)
2633+ }
2634+
2635+ init(fromURL url: URL) throws {
2636+ try self.init(data: try Data(contentsOf: url))
2637+ }
2638+
2639+ func with(
2640+ beholdable: JSONNull?? = nil,
2641+ brotuliform: JSONNull?? = nil,
2642+ chimakum: JSONNull?? = nil,
2643+ doodler: JSONNull?? = nil,
2644+ emulsin: JSONNull?? = nil,
2645+ fin: JSONNull?? = nil,
2646+ flourishing: JSONNull?? = nil,
2647+ flueless: JSONNull?? = nil,
2648+ furtively: JSONNull?? = nil,
2649+ gritter: JSONNull?? = nil,
2650+ interwish: JSONNull?? = nil,
2651+ monoxylic: JSONNull?? = nil,
2652+ myristic: JSONNull?? = nil,
2653+ nightwear: JSONNull?? = nil,
2654+ peruser: JSONNull?? = nil,
2655+ theoastrological: JSONNull?? = nil,
2656+ thumby: JSONNull?? = nil,
2657+ tingitid: JSONNull?? = nil,
2658+ trailless: JSONNull?? = nil,
2659+ unpocketed: JSONNull?? = nil
2660+ ) -> TopLevel.OccupationalistClass {
2661+ return TopLevel.OccupationalistClass(
2662+ beholdable: beholdable ?? self.beholdable,
2663+ brotuliform: brotuliform ?? self.brotuliform,
2664+ chimakum: chimakum ?? self.chimakum,
2665+ doodler: doodler ?? self.doodler,
2666+ emulsin: emulsin ?? self.emulsin,
2667+ fin: fin ?? self.fin,
2668+ flourishing: flourishing ?? self.flourishing,
2669+ flueless: flueless ?? self.flueless,
2670+ furtively: furtively ?? self.furtively,
2671+ gritter: gritter ?? self.gritter,
2672+ interwish: interwish ?? self.interwish,
2673+ monoxylic: monoxylic ?? self.monoxylic,
2674+ myristic: myristic ?? self.myristic,
2675+ nightwear: nightwear ?? self.nightwear,
2676+ peruser: peruser ?? self.peruser,
2677+ theoastrological: theoastrological ?? self.theoastrological,
2678+ thumby: thumby ?? self.thumby,
2679+ tingitid: tingitid ?? self.tingitid,
2680+ trailless: trailless ?? self.trailless,
2681+ unpocketed: unpocketed ?? self.unpocketed
2682+ )
2683+ }
2684+
2685+ func jsonData() throws -> Data {
2686+ return try TopLevel.newJSONEncoder().encode(self)
2687+ }
2688+
2689+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2690+ return String(data: try self.jsonData(), encoding: encoding)
2691+ }
2692+}
2693+
2694+extension TopLevel.OutrivalClass {
2695+ init(data: Data) throws {
2696+ self = try TopLevel.newJSONDecoder().decode(TopLevel.OutrivalClass.self, from: data)
2697+ }
2698+
2699+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2700+ guard let data = json.data(using: encoding) else {
2701+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2702+ }
2703+ try self.init(data: data)
2704+ }
2705+
2706+ init(fromURL url: URL) throws {
2707+ try self.init(data: try Data(contentsOf: url))
2708+ }
2709+
2710+ func with(
2711+ adroitly: JSONNull?? = nil,
2712+ bridehood: JSONNull?? = nil,
2713+ castoroides: JSONNull?? = nil,
2714+ czechoslovak: JSONNull?? = nil,
2715+ diagenesis: JSONNull?? = nil,
2716+ dihexahedron: JSONNull?? = nil,
2717+ dopester: JSONNull?? = nil,
2718+ eumerism: JSONNull?? = nil,
2719+ flyness: JSONNull?? = nil,
2720+ fouler: JSONNull?? = nil,
2721+ laudanosine: JSONNull?? = nil,
2722+ lingulidae: JSONNull?? = nil,
2723+ minutary: JSONNull?? = nil,
2724+ mitra: JSONNull?? = nil,
2725+ opisthorchiasis: JSONNull?? = nil,
2726+ pensively: JSONNull?? = nil,
2727+ pubigerous: JSONNull?? = nil,
2728+ rebellious: JSONNull?? = nil,
2729+ recodify: JSONNull?? = nil,
2730+ unpaced: JSONNull?? = nil
2731+ ) -> TopLevel.OutrivalClass {
2732+ return TopLevel.OutrivalClass(
2733+ adroitly: adroitly ?? self.adroitly,
2734+ bridehood: bridehood ?? self.bridehood,
2735+ castoroides: castoroides ?? self.castoroides,
2736+ czechoslovak: czechoslovak ?? self.czechoslovak,
2737+ diagenesis: diagenesis ?? self.diagenesis,
2738+ dihexahedron: dihexahedron ?? self.dihexahedron,
2739+ dopester: dopester ?? self.dopester,
2740+ eumerism: eumerism ?? self.eumerism,
2741+ flyness: flyness ?? self.flyness,
2742+ fouler: fouler ?? self.fouler,
2743+ laudanosine: laudanosine ?? self.laudanosine,
2744+ lingulidae: lingulidae ?? self.lingulidae,
2745+ minutary: minutary ?? self.minutary,
2746+ mitra: mitra ?? self.mitra,
2747+ opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis,
2748+ pensively: pensively ?? self.pensively,
2749+ pubigerous: pubigerous ?? self.pubigerous,
2750+ rebellious: rebellious ?? self.rebellious,
2751+ recodify: recodify ?? self.recodify,
2752+ unpaced: unpaced ?? self.unpaced
2753+ )
2754+ }
2755+
2756+ func jsonData() throws -> Data {
2757+ return try TopLevel.newJSONEncoder().encode(self)
2758+ }
2759+
2760+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2761+ return String(data: try self.jsonData(), encoding: encoding)
2762+ }
2763+}
2764+
2765+extension TopLevel.PiaculumClass {
2766+ init(data: Data) throws {
2767+ self = try TopLevel.newJSONDecoder().decode(TopLevel.PiaculumClass.self, from: data)
2768+ }
2769+
2770+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2771+ guard let data = json.data(using: encoding) else {
2772+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2773+ }
2774+ try self.init(data: data)
2775+ }
2776+
2777+ init(fromURL url: URL) throws {
2778+ try self.init(data: try Data(contentsOf: url))
2779+ }
2780+
2781+ func with(
2782+ alada: Int?? = nil,
2783+ amphistomous: Int?? = nil,
2784+ boysenberry: Int?? = nil,
2785+ catharticalness: Double?? = nil,
2786+ chirotherium: Int?? = nil,
2787+ decardinalize: Int?? = nil,
2788+ discouragement: Int?? = nil,
2789+ disdiapason: String?? = nil,
2790+ doitrified: Int?? = nil,
2791+ hexaspermous: Int?? = nil,
2792+ homocerc: Bool?? = nil,
2793+ insinking: Int?? = nil,
2794+ loathfulness: Int?? = nil,
2795+ miasmatical: Int?? = nil,
2796+ neurofibril: Int?? = nil,
2797+ nonbookish: JSONNull?? = nil,
2798+ phonendoscope: Int?? = nil,
2799+ pilferment: Int?? = nil,
2800+ predismissory: Int?? = nil,
2801+ preinscription: Int?? = nil,
2802+ quotative: Int?? = nil,
2803+ sienna: Int?? = nil,
2804+ thorax: Int?? = nil,
2805+ yachting: Int?? = nil,
2806+ zipper: Int?? = nil
2807+ ) -> TopLevel.PiaculumClass {
2808+ return TopLevel.PiaculumClass(
2809+ alada: alada ?? self.alada,
2810+ amphistomous: amphistomous ?? self.amphistomous,
2811+ boysenberry: boysenberry ?? self.boysenberry,
2812+ catharticalness: catharticalness ?? self.catharticalness,
2813+ chirotherium: chirotherium ?? self.chirotherium,
2814+ decardinalize: decardinalize ?? self.decardinalize,
2815+ discouragement: discouragement ?? self.discouragement,
2816+ disdiapason: disdiapason ?? self.disdiapason,
2817+ doitrified: doitrified ?? self.doitrified,
2818+ hexaspermous: hexaspermous ?? self.hexaspermous,
2819+ homocerc: homocerc ?? self.homocerc,
2820+ insinking: insinking ?? self.insinking,
2821+ loathfulness: loathfulness ?? self.loathfulness,
2822+ miasmatical: miasmatical ?? self.miasmatical,
2823+ neurofibril: neurofibril ?? self.neurofibril,
2824+ nonbookish: nonbookish ?? self.nonbookish,
2825+ phonendoscope: phonendoscope ?? self.phonendoscope,
2826+ pilferment: pilferment ?? self.pilferment,
2827+ predismissory: predismissory ?? self.predismissory,
2828+ preinscription: preinscription ?? self.preinscription,
2829+ quotative: quotative ?? self.quotative,
2830+ sienna: sienna ?? self.sienna,
2831+ thorax: thorax ?? self.thorax,
2832+ yachting: yachting ?? self.yachting,
2833+ zipper: zipper ?? self.zipper
2834+ )
2835+ }
2836+
2837+ func jsonData() throws -> Data {
2838+ return try TopLevel.newJSONEncoder().encode(self)
2839+ }
2840+
2841+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2842+ return String(data: try self.jsonData(), encoding: encoding)
2843+ }
2844+}
2845+
2846+extension TopLevel.Pneumocele {
2847+ init(data: Data) throws {
2848+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Pneumocele.self, from: data)
2849+ }
2850+
2851+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2852+ guard let data = json.data(using: encoding) else {
2853+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2854+ }
2855+ try self.init(data: data)
2856+ }
2857+
2858+ init(fromURL url: URL) throws {
2859+ try self.init(data: try Data(contentsOf: url))
2860+ }
2861+
2862+ func with(
2863+ carbonarism: JSONNull?? = nil,
2864+ catharticalness: Double?? = nil,
2865+ chirotherium: Int?? = nil,
2866+ cineolic: JSONNull?? = nil,
2867+ cobbly: JSONNull?? = nil,
2868+ conchyliferous: JSONNull?? = nil,
2869+ congregation: JSONNull?? = nil,
2870+ disdiapason: String?? = nil,
2871+ enterotomy: JSONNull?? = nil,
2872+ entophytal: JSONNull?? = nil,
2873+ fewtrils: JSONNull?? = nil,
2874+ herem: JSONNull?? = nil,
2875+ homocerc: Bool?? = nil,
2876+ koniga: JSONNull?? = nil,
2877+ meticulosity: JSONNull?? = nil,
2878+ micky: JSONNull?? = nil,
2879+ mismarriage: JSONNull?? = nil,
2880+ neurotrophic: JSONNull?? = nil,
2881+ nonbookish: JSONNull?? = nil,
2882+ persuasively: JSONNull?? = nil,
2883+ replaceable: JSONNull?? = nil,
2884+ silex: JSONNull?? = nil,
2885+ taillight: JSONNull?? = nil,
2886+ unjealous: JSONNull?? = nil,
2887+ visitorial: JSONNull?? = nil
2888+ ) -> TopLevel.Pneumocele {
2889+ return TopLevel.Pneumocele(
2890+ carbonarism: carbonarism ?? self.carbonarism,
2891+ catharticalness: catharticalness ?? self.catharticalness,
2892+ chirotherium: chirotherium ?? self.chirotherium,
2893+ cineolic: cineolic ?? self.cineolic,
2894+ cobbly: cobbly ?? self.cobbly,
2895+ conchyliferous: conchyliferous ?? self.conchyliferous,
2896+ congregation: congregation ?? self.congregation,
2897+ disdiapason: disdiapason ?? self.disdiapason,
2898+ enterotomy: enterotomy ?? self.enterotomy,
2899+ entophytal: entophytal ?? self.entophytal,
2900+ fewtrils: fewtrils ?? self.fewtrils,
2901+ herem: herem ?? self.herem,
2902+ homocerc: homocerc ?? self.homocerc,
2903+ koniga: koniga ?? self.koniga,
2904+ meticulosity: meticulosity ?? self.meticulosity,
2905+ micky: micky ?? self.micky,
2906+ mismarriage: mismarriage ?? self.mismarriage,
2907+ neurotrophic: neurotrophic ?? self.neurotrophic,
2908+ nonbookish: nonbookish ?? self.nonbookish,
2909+ persuasively: persuasively ?? self.persuasively,
2910+ replaceable: replaceable ?? self.replaceable,
2911+ silex: silex ?? self.silex,
2912+ taillight: taillight ?? self.taillight,
2913+ unjealous: unjealous ?? self.unjealous,
2914+ visitorial: visitorial ?? self.visitorial
2915+ )
2916+ }
2917+
2918+ func jsonData() throws -> Data {
2919+ return try TopLevel.newJSONEncoder().encode(self)
2920+ }
2921+
2922+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2923+ return String(data: try self.jsonData(), encoding: encoding)
2924+ }
2925+}
2926+
2927+extension TopLevel.PotwhiskyClass {
2928+ init(data: Data) throws {
2929+ self = try TopLevel.newJSONDecoder().decode(TopLevel.PotwhiskyClass.self, from: data)
2930+ }
2931+
2932+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2933+ guard let data = json.data(using: encoding) else {
2934+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2935+ }
2936+ try self.init(data: data)
2937+ }
2938+
2939+ init(fromURL url: URL) throws {
2940+ try self.init(data: try Data(contentsOf: url))
2941+ }
2942+
2943+ func with(
2944+ arciform: JSONNull?? = nil,
2945+ cresolin: JSONNull?? = nil,
2946+ disheartener: JSONNull?? = nil,
2947+ disproportionable: JSONNull?? = nil,
2948+ euchorda: JSONNull?? = nil,
2949+ ferryway: JSONNull?? = nil,
2950+ filamentiferous: JSONNull?? = nil,
2951+ flemish: JSONNull?? = nil,
2952+ forgainst: JSONNull?? = nil,
2953+ grainering: JSONNull?? = nil,
2954+ irrevoluble: JSONNull?? = nil,
2955+ kindredship: JSONNull?? = nil,
2956+ pinguitudinous: JSONNull?? = nil,
2957+ simpletonic: JSONNull?? = nil,
2958+ singsong: JSONNull?? = nil,
2959+ submergement: JSONNull?? = nil,
2960+ supraoesophagal: JSONNull?? = nil,
2961+ thrashel: JSONNull?? = nil,
2962+ tyremesis: JSONNull?? = nil,
2963+ yoruba: JSONNull?? = nil
2964+ ) -> TopLevel.PotwhiskyClass {
2965+ return TopLevel.PotwhiskyClass(
2966+ arciform: arciform ?? self.arciform,
2967+ cresolin: cresolin ?? self.cresolin,
2968+ disheartener: disheartener ?? self.disheartener,
2969+ disproportionable: disproportionable ?? self.disproportionable,
2970+ euchorda: euchorda ?? self.euchorda,
2971+ ferryway: ferryway ?? self.ferryway,
2972+ filamentiferous: filamentiferous ?? self.filamentiferous,
2973+ flemish: flemish ?? self.flemish,
2974+ forgainst: forgainst ?? self.forgainst,
2975+ grainering: grainering ?? self.grainering,
2976+ irrevoluble: irrevoluble ?? self.irrevoluble,
2977+ kindredship: kindredship ?? self.kindredship,
2978+ pinguitudinous: pinguitudinous ?? self.pinguitudinous,
2979+ simpletonic: simpletonic ?? self.simpletonic,
2980+ singsong: singsong ?? self.singsong,
2981+ submergement: submergement ?? self.submergement,
2982+ supraoesophagal: supraoesophagal ?? self.supraoesophagal,
2983+ thrashel: thrashel ?? self.thrashel,
2984+ tyremesis: tyremesis ?? self.tyremesis,
2985+ yoruba: yoruba ?? self.yoruba
2986+ )
2987+ }
2988+
2989+ func jsonData() throws -> Data {
2990+ return try TopLevel.newJSONEncoder().encode(self)
2991+ }
2992+
2993+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2994+ return String(data: try self.jsonData(), encoding: encoding)
2995+ }
2996+}
2997+
2998+extension TopLevel.PrefreshmanClass {
2999+ init(data: Data) throws {
3000+ self = try TopLevel.newJSONDecoder().decode(TopLevel.PrefreshmanClass.self, from: data)
3001+ }
3002+
3003+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3004+ guard let data = json.data(using: encoding) else {
3005+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3006+ }
3007+ try self.init(data: data)
3008+ }
3009+
3010+ init(fromURL url: URL) throws {
3011+ try self.init(data: try Data(contentsOf: url))
3012+ }
3013+
3014+ func with(
3015+ azorubine: JSONNull?? = nil,
3016+ choroiditis: JSONNull?? = nil,
3017+ coagulatory: JSONNull?? = nil,
3018+ cyclorama: JSONNull?? = nil,
3019+ dolphus: JSONNull?? = nil,
3020+ duckhearted: JSONNull?? = nil,
3021+ ficus: JSONNull?? = nil,
3022+ gemaric: JSONNull?? = nil,
3023+ jugation: JSONNull?? = nil,
3024+ myoliposis: JSONNull?? = nil,
3025+ nonnomination: JSONNull?? = nil,
3026+ palay: JSONNull?? = nil,
3027+ pentactinal: JSONNull?? = nil,
3028+ phaet: JSONNull?? = nil,
3029+ piquant: JSONNull?? = nil,
3030+ registration: JSONNull?? = nil,
3031+ remancipation: JSONNull?? = nil,
3032+ scutatiform: JSONNull?? = nil,
3033+ theodolite: JSONNull?? = nil,
3034+ underward: JSONNull?? = nil
3035+ ) -> TopLevel.PrefreshmanClass {
3036+ return TopLevel.PrefreshmanClass(
3037+ azorubine: azorubine ?? self.azorubine,
3038+ choroiditis: choroiditis ?? self.choroiditis,
3039+ coagulatory: coagulatory ?? self.coagulatory,
3040+ cyclorama: cyclorama ?? self.cyclorama,
3041+ dolphus: dolphus ?? self.dolphus,
3042+ duckhearted: duckhearted ?? self.duckhearted,
3043+ ficus: ficus ?? self.ficus,
3044+ gemaric: gemaric ?? self.gemaric,
3045+ jugation: jugation ?? self.jugation,
3046+ myoliposis: myoliposis ?? self.myoliposis,
3047+ nonnomination: nonnomination ?? self.nonnomination,
3048+ palay: palay ?? self.palay,
3049+ pentactinal: pentactinal ?? self.pentactinal,
3050+ phaet: phaet ?? self.phaet,
3051+ piquant: piquant ?? self.piquant,
3052+ registration: registration ?? self.registration,
3053+ remancipation: remancipation ?? self.remancipation,
3054+ scutatiform: scutatiform ?? self.scutatiform,
3055+ theodolite: theodolite ?? self.theodolite,
3056+ underward: underward ?? self.underward
3057+ )
3058+ }
3059+
3060+ func jsonData() throws -> Data {
3061+ return try TopLevel.newJSONEncoder().encode(self)
3062+ }
3063+
3064+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3065+ return String(data: try self.jsonData(), encoding: encoding)
3066+ }
3067+}
3068+
3069+// MARK: - Encode/decode helpers
3070+
3071+class JSONNull: Codable, Hashable {
3072+
3073+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3074+ return true
3075+ }
3076+
3077+ public func hash(into hasher: inout Hasher) {
3078+ hasher.combine(0)
3079+ }
3080+
3081+ public init() {}
3082+
3083+ public required init(from decoder: Decoder) throws {
3084+ let container = try decoder.singleValueContainer()
3085+ if !container.decodeNil() {
3086+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3087+ }
3088+ }
3089+
3090+ public func encode(to encoder: Encoder) throws {
3091+ var container = encoder.singleValueContainer()
3092+ try container.encodeNil()
3093+ }
3094+}
Test case

test/inputs/json/priority/combinations4.json

1 generated file · +3,592 −0
Aswiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+3,592 −0
@@ -0,0 +1,3592 @@
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+ // MARK: Helper functions for creating encoders and decoders
2229+ static func newJSONDecoder() -> JSONDecoder {
2230+ let decoder = JSONDecoder()
2231+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
2232+ let container = try decoder.singleValueContainer()
2233+ let dateStr = try container.decode(String.self)
2234+
2235+ let formatter = DateFormatter()
2236+ formatter.calendar = Calendar(identifier: .iso8601)
2237+ formatter.locale = Locale(identifier: "en_US_POSIX")
2238+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2239+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
2240+ if let date = formatter.date(from: dateStr) {
2241+ return date
2242+ }
2243+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
2244+ if let date = formatter.date(from: dateStr) {
2245+ return date
2246+ }
2247+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
2248+ })
2249+ return decoder
2250+ }
2251+
2252+ static func newJSONEncoder() -> JSONEncoder {
2253+ let encoder = JSONEncoder()
2254+ let formatter = DateFormatter()
2255+ formatter.calendar = Calendar(identifier: .iso8601)
2256+ formatter.locale = Locale(identifier: "en_US_POSIX")
2257+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
2258+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
2259+ encoder.dateEncodingStrategy = .formatted(formatter)
2260+ return encoder
2261+ }
2262+}
2263+
2264+// MARK: TopLevel convenience initializers and mutators
2265+
2266+extension TopLevel {
2267+ init(data: Data) throws {
2268+ self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data)
2269+ }
2270+
2271+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2272+ guard let data = json.data(using: encoding) else {
2273+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2274+ }
2275+ try self.init(data: data)
2276+ }
2277+
2278+ init(fromURL url: URL) throws {
2279+ try self.init(data: try Data(contentsOf: url))
2280+ }
2281+
2282+ func with(
2283+ protrusive: [TopLevel.Protrusive]? = nil,
2284+ pulpitism: [TopLevel.PulpitismElement]? = nil,
2285+ pyodermia: [TopLevel.PyodermiaElement]? = nil,
2286+ quebrachine: [TopLevel.QuebrachineElement]? = nil,
2287+ querier: [TopLevel.Querier]? = nil,
2288+ rebarbative: [TopLevel.Rebarbative]? = nil,
2289+ reimagine: [TopLevel.Reimagine]? = nil,
2290+ ressaut: TopLevel.Ressaut? = nil,
2291+ retrocervical: [TopLevel.Retrocervical]? = nil,
2292+ revert: [TopLevel.Revert]? = nil,
2293+ rewrite: [TopLevel.RewriteElement]? = nil,
2294+ saccoderm: [TopLevel.Saccoderm]? = nil,
2295+ santir: [TopLevel.SantirElement]? = nil,
2296+ saprophilous: [TopLevel.Saprophilous]? = nil,
2297+ saxten: [TopLevel.SaxtenElement]? = nil,
2298+ scatty: [TopLevel.Scatty?]? = nil,
2299+ scoffer: [TopLevel.Scoffer]? = nil,
2300+ scrampum: [TopLevel.Scrampum]? = nil,
2301+ semantic: Double? = nil,
2302+ serpentinic: [TopLevel.Serpentinic]? = nil,
2303+ shadowable: [TopLevel.Shadowable]? = nil,
2304+ sistering: [TopLevel.SisteringElement]? = nil,
2305+ staghunting: [TopLevel.Staghunting]? = nil,
2306+ stagmometer: [TopLevel.Stagmometer]? = nil,
2307+ stimulability: [TopLevel.Stimulability]? = nil,
2308+ strangleable: [TopLevel.Strangleable]? = nil,
2309+ strenuosity: [TopLevel.StrenuosityElement]? = nil,
2310+ tabaxir: [TopLevel.Tabaxir]? = nil,
2311+ talpiform: [TopLevel.Talpiform]? = nil,
2312+ thwack: [TopLevel.Thwack]? = nil,
2313+ to: [Double?]? = nil,
2314+ tortricine: [TopLevel.Tortricine]? = nil,
2315+ truantcy: [TopLevel.TruantcyElement]? = nil,
2316+ turgesce: [String]? = nil,
2317+ unbeginning: [TopLevel.Unbeginning]? = nil,
2318+ underdunged: [Double]? = nil,
2319+ undesirability: [TopLevel.Undesirability]? = nil,
2320+ unerasing: [TopLevel.Unerasing]? = nil,
2321+ unguentarium: [TopLevel.Unguentarium]? = nil,
2322+ unimpeachably: [TopLevel.UnimpeachablyElement]? = nil,
2323+ unmortgaged: [TopLevel.Unmortgaged]? = nil,
2324+ unobstructed: [TopLevel.Unobstructed]? = nil,
2325+ unreceptivity: [TopLevel.Unreceptivity]? = nil,
2326+ unsatisfactoriness: [TopLevel.Unsatisfactoriness]? = nil,
2327+ unsecurity: [Int]? = nil,
2328+ unstressed: [TopLevel.UnstressedElement]? = nil,
2329+ untasked: [TopLevel.Untasked]? = nil,
2330+ unvarying: [TopLevel.Unvarying]? = nil,
2331+ vehemently: [TopLevel.Vehemently]? = nil,
2332+ warriorship: [String: Bool]? = nil,
2333+ whitepot: [TopLevel.Whitepot]? = nil,
2334+ wrothy: [TopLevel.WrothyElement]? = nil
2335+ ) -> TopLevel {
2336+ return TopLevel(
2337+ protrusive: protrusive ?? self.protrusive,
2338+ pulpitism: pulpitism ?? self.pulpitism,
2339+ pyodermia: pyodermia ?? self.pyodermia,
2340+ quebrachine: quebrachine ?? self.quebrachine,
2341+ querier: querier ?? self.querier,
2342+ rebarbative: rebarbative ?? self.rebarbative,
2343+ reimagine: reimagine ?? self.reimagine,
2344+ ressaut: ressaut ?? self.ressaut,
2345+ retrocervical: retrocervical ?? self.retrocervical,
2346+ revert: revert ?? self.revert,
2347+ rewrite: rewrite ?? self.rewrite,
2348+ saccoderm: saccoderm ?? self.saccoderm,
2349+ santir: santir ?? self.santir,
2350+ saprophilous: saprophilous ?? self.saprophilous,
2351+ saxten: saxten ?? self.saxten,
2352+ scatty: scatty ?? self.scatty,
2353+ scoffer: scoffer ?? self.scoffer,
2354+ scrampum: scrampum ?? self.scrampum,
2355+ semantic: semantic ?? self.semantic,
2356+ serpentinic: serpentinic ?? self.serpentinic,
2357+ shadowable: shadowable ?? self.shadowable,
2358+ sistering: sistering ?? self.sistering,
2359+ staghunting: staghunting ?? self.staghunting,
2360+ stagmometer: stagmometer ?? self.stagmometer,
2361+ stimulability: stimulability ?? self.stimulability,
2362+ strangleable: strangleable ?? self.strangleable,
2363+ strenuosity: strenuosity ?? self.strenuosity,
2364+ tabaxir: tabaxir ?? self.tabaxir,
2365+ talpiform: talpiform ?? self.talpiform,
2366+ thwack: thwack ?? self.thwack,
2367+ to: to ?? self.to,
2368+ tortricine: tortricine ?? self.tortricine,
2369+ truantcy: truantcy ?? self.truantcy,
2370+ turgesce: turgesce ?? self.turgesce,
2371+ unbeginning: unbeginning ?? self.unbeginning,
2372+ underdunged: underdunged ?? self.underdunged,
2373+ undesirability: undesirability ?? self.undesirability,
2374+ unerasing: unerasing ?? self.unerasing,
2375+ unguentarium: unguentarium ?? self.unguentarium,
2376+ unimpeachably: unimpeachably ?? self.unimpeachably,
2377+ unmortgaged: unmortgaged ?? self.unmortgaged,
2378+ unobstructed: unobstructed ?? self.unobstructed,
2379+ unreceptivity: unreceptivity ?? self.unreceptivity,
2380+ unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness,
2381+ unsecurity: unsecurity ?? self.unsecurity,
2382+ unstressed: unstressed ?? self.unstressed,
2383+ untasked: untasked ?? self.untasked,
2384+ unvarying: unvarying ?? self.unvarying,
2385+ vehemently: vehemently ?? self.vehemently,
2386+ warriorship: warriorship ?? self.warriorship,
2387+ whitepot: whitepot ?? self.whitepot,
2388+ wrothy: wrothy ?? self.wrothy
2389+ )
2390+ }
2391+
2392+ func jsonData() throws -> Data {
2393+ return try TopLevel.newJSONEncoder().encode(self)
2394+ }
2395+
2396+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2397+ return String(data: try self.jsonData(), encoding: encoding)
2398+ }
2399+}
2400+
2401+extension TopLevel.PulpitismClass {
2402+ init(data: Data) throws {
2403+ self = try TopLevel.newJSONDecoder().decode(TopLevel.PulpitismClass.self, from: data)
2404+ }
2405+
2406+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2407+ guard let data = json.data(using: encoding) else {
2408+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2409+ }
2410+ try self.init(data: data)
2411+ }
2412+
2413+ init(fromURL url: URL) throws {
2414+ try self.init(data: try Data(contentsOf: url))
2415+ }
2416+
2417+ func with(
2418+ abnet: JSONNull?? = nil,
2419+ buckhorn: JSONNull?? = nil,
2420+ calciform: JSONNull?? = nil,
2421+ chelophore: JSONNull?? = nil,
2422+ cogitation: JSONNull?? = nil,
2423+ decreeable: JSONNull?? = nil,
2424+ despicable: JSONNull?? = nil,
2425+ isodiazo: JSONNull?? = nil,
2426+ jadedly: JSONNull?? = nil,
2427+ leptochlorite: JSONNull?? = nil,
2428+ nursling: JSONNull?? = nil,
2429+ palamedean: JSONNull?? = nil,
2430+ photoheliograph: JSONNull?? = nil,
2431+ pipewood: JSONNull?? = nil,
2432+ roberd: JSONNull?? = nil,
2433+ statable: JSONNull?? = nil,
2434+ superassume: JSONNull?? = nil,
2435+ syllabe: JSONNull?? = nil,
2436+ toughhead: JSONNull?? = nil,
2437+ underburn: JSONNull?? = nil
2438+ ) -> TopLevel.PulpitismClass {
2439+ return TopLevel.PulpitismClass(
2440+ abnet: abnet ?? self.abnet,
2441+ buckhorn: buckhorn ?? self.buckhorn,
2442+ calciform: calciform ?? self.calciform,
2443+ chelophore: chelophore ?? self.chelophore,
2444+ cogitation: cogitation ?? self.cogitation,
2445+ decreeable: decreeable ?? self.decreeable,
2446+ despicable: despicable ?? self.despicable,
2447+ isodiazo: isodiazo ?? self.isodiazo,
2448+ jadedly: jadedly ?? self.jadedly,
2449+ leptochlorite: leptochlorite ?? self.leptochlorite,
2450+ nursling: nursling ?? self.nursling,
2451+ palamedean: palamedean ?? self.palamedean,
2452+ photoheliograph: photoheliograph ?? self.photoheliograph,
2453+ pipewood: pipewood ?? self.pipewood,
2454+ roberd: roberd ?? self.roberd,
2455+ statable: statable ?? self.statable,
2456+ superassume: superassume ?? self.superassume,
2457+ syllabe: syllabe ?? self.syllabe,
2458+ toughhead: toughhead ?? self.toughhead,
2459+ underburn: underburn ?? self.underburn
2460+ )
2461+ }
2462+
2463+ func jsonData() throws -> Data {
2464+ return try TopLevel.newJSONEncoder().encode(self)
2465+ }
2466+
2467+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2468+ return String(data: try self.jsonData(), encoding: encoding)
2469+ }
2470+}
2471+
2472+extension TopLevel.PyodermiaClass {
2473+ init(data: Data) throws {
2474+ self = try TopLevel.newJSONDecoder().decode(TopLevel.PyodermiaClass.self, from: data)
2475+ }
2476+
2477+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2478+ guard let data = json.data(using: encoding) else {
2479+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2480+ }
2481+ try self.init(data: data)
2482+ }
2483+
2484+ init(fromURL url: URL) throws {
2485+ try self.init(data: try Data(contentsOf: url))
2486+ }
2487+
2488+ func with(
2489+ aphoristically: JSONNull?? = nil,
2490+ apophyllous: JSONNull?? = nil,
2491+ cognize: JSONNull?? = nil,
2492+ dermonosology: JSONNull?? = nil,
2493+ gyppo: JSONNull?? = nil,
2494+ ither: JSONNull?? = nil,
2495+ juglandaceous: JSONNull?? = nil,
2496+ litho: JSONNull?? = nil,
2497+ macropterous: JSONNull?? = nil,
2498+ photographer: JSONNull?? = nil,
2499+ romancing: JSONNull?? = nil,
2500+ rumness: JSONNull?? = nil,
2501+ somniloquist: JSONNull?? = nil,
2502+ stressfully: JSONNull?? = nil,
2503+ tactically: JSONNull?? = nil,
2504+ tracheophony: JSONNull?? = nil,
2505+ unappositely: JSONNull?? = nil,
2506+ unclothedly: JSONNull?? = nil,
2507+ unimplied: JSONNull?? = nil,
2508+ unsyncopated: JSONNull?? = nil
2509+ ) -> TopLevel.PyodermiaClass {
2510+ return TopLevel.PyodermiaClass(
2511+ aphoristically: aphoristically ?? self.aphoristically,
2512+ apophyllous: apophyllous ?? self.apophyllous,
2513+ cognize: cognize ?? self.cognize,
2514+ dermonosology: dermonosology ?? self.dermonosology,
2515+ gyppo: gyppo ?? self.gyppo,
2516+ ither: ither ?? self.ither,
2517+ juglandaceous: juglandaceous ?? self.juglandaceous,
2518+ litho: litho ?? self.litho,
2519+ macropterous: macropterous ?? self.macropterous,
2520+ photographer: photographer ?? self.photographer,
2521+ romancing: romancing ?? self.romancing,
2522+ rumness: rumness ?? self.rumness,
2523+ somniloquist: somniloquist ?? self.somniloquist,
2524+ stressfully: stressfully ?? self.stressfully,
2525+ tactically: tactically ?? self.tactically,
2526+ tracheophony: tracheophony ?? self.tracheophony,
2527+ unappositely: unappositely ?? self.unappositely,
2528+ unclothedly: unclothedly ?? self.unclothedly,
2529+ unimplied: unimplied ?? self.unimplied,
2530+ unsyncopated: unsyncopated ?? self.unsyncopated
2531+ )
2532+ }
2533+
2534+ func jsonData() throws -> Data {
2535+ return try TopLevel.newJSONEncoder().encode(self)
2536+ }
2537+
2538+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2539+ return String(data: try self.jsonData(), encoding: encoding)
2540+ }
2541+}
2542+
2543+extension TopLevel.QuebrachineClass {
2544+ init(data: Data) throws {
2545+ self = try TopLevel.newJSONDecoder().decode(TopLevel.QuebrachineClass.self, from: data)
2546+ }
2547+
2548+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2549+ guard let data = json.data(using: encoding) else {
2550+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2551+ }
2552+ try self.init(data: data)
2553+ }
2554+
2555+ init(fromURL url: URL) throws {
2556+ try self.init(data: try Data(contentsOf: url))
2557+ }
2558+
2559+ func with(
2560+ catharticalness: Double? = nil,
2561+ chirotherium: Int? = nil,
2562+ disdiapason: String? = nil,
2563+ homocerc: Bool? = nil,
2564+ nonbookish: JSONNull?? = nil
2565+ ) -> TopLevel.QuebrachineClass {
2566+ return TopLevel.QuebrachineClass(
2567+ catharticalness: catharticalness ?? self.catharticalness,
2568+ chirotherium: chirotherium ?? self.chirotherium,
2569+ disdiapason: disdiapason ?? self.disdiapason,
2570+ homocerc: homocerc ?? self.homocerc,
2571+ nonbookish: nonbookish ?? self.nonbookish
2572+ )
2573+ }
2574+
2575+ func jsonData() throws -> Data {
2576+ return try TopLevel.newJSONEncoder().encode(self)
2577+ }
2578+
2579+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2580+ return String(data: try self.jsonData(), encoding: encoding)
2581+ }
2582+}
2583+
2584+extension TopLevel.Reimagine {
2585+ init(data: Data) throws {
2586+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Reimagine.self, from: data)
2587+ }
2588+
2589+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2590+ guard let data = json.data(using: encoding) else {
2591+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2592+ }
2593+ try self.init(data: data)
2594+ }
2595+
2596+ init(fromURL url: URL) throws {
2597+ try self.init(data: try Data(contentsOf: url))
2598+ }
2599+
2600+ func with(
2601+ adducible: JSONNull?? = nil,
2602+ anabolin: JSONNull?? = nil,
2603+ brainy: JSONNull?? = nil,
2604+ catharticalness: Double?? = nil,
2605+ chirotherium: Int?? = nil,
2606+ chrysamine: JSONNull?? = nil,
2607+ disdiapason: String?? = nil,
2608+ fluxweed: JSONNull?? = nil,
2609+ glaucine: JSONNull?? = nil,
2610+ grobianism: JSONNull?? = nil,
2611+ hermo: JSONNull?? = nil,
2612+ hieroglyphist: JSONNull?? = nil,
2613+ homocerc: Bool?? = nil,
2614+ icteroid: JSONNull?? = nil,
2615+ immortal: JSONNull?? = nil,
2616+ impetulant: JSONNull?? = nil,
2617+ irrigate: JSONNull?? = nil,
2618+ myxedema: JSONNull?? = nil,
2619+ nonbookish: JSONNull?? = nil,
2620+ onyx: JSONNull?? = nil,
2621+ repasser: JSONNull?? = nil,
2622+ septomarginal: JSONNull?? = nil,
2623+ subdie: JSONNull?? = nil,
2624+ tibiometatarsal: JSONNull?? = nil,
2625+ waltzlike: JSONNull?? = nil
2626+ ) -> TopLevel.Reimagine {
2627+ return TopLevel.Reimagine(
2628+ adducible: adducible ?? self.adducible,
2629+ anabolin: anabolin ?? self.anabolin,
2630+ brainy: brainy ?? self.brainy,
2631+ catharticalness: catharticalness ?? self.catharticalness,
2632+ chirotherium: chirotherium ?? self.chirotherium,
2633+ chrysamine: chrysamine ?? self.chrysamine,
2634+ disdiapason: disdiapason ?? self.disdiapason,
2635+ fluxweed: fluxweed ?? self.fluxweed,
2636+ glaucine: glaucine ?? self.glaucine,
2637+ grobianism: grobianism ?? self.grobianism,
2638+ hermo: hermo ?? self.hermo,
2639+ hieroglyphist: hieroglyphist ?? self.hieroglyphist,
2640+ homocerc: homocerc ?? self.homocerc,
2641+ icteroid: icteroid ?? self.icteroid,
2642+ immortal: immortal ?? self.immortal,
2643+ impetulant: impetulant ?? self.impetulant,
2644+ irrigate: irrigate ?? self.irrigate,
2645+ myxedema: myxedema ?? self.myxedema,
2646+ nonbookish: nonbookish ?? self.nonbookish,
2647+ onyx: onyx ?? self.onyx,
2648+ repasser: repasser ?? self.repasser,
2649+ septomarginal: septomarginal ?? self.septomarginal,
2650+ subdie: subdie ?? self.subdie,
2651+ tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal,
2652+ waltzlike: waltzlike ?? self.waltzlike
2653+ )
2654+ }
2655+
2656+ func jsonData() throws -> Data {
2657+ return try TopLevel.newJSONEncoder().encode(self)
2658+ }
2659+
2660+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2661+ return String(data: try self.jsonData(), encoding: encoding)
2662+ }
2663+}
2664+
2665+extension TopLevel.Ressaut {
2666+ init(data: Data) throws {
2667+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Ressaut.self, from: data)
2668+ }
2669+
2670+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2671+ guard let data = json.data(using: encoding) else {
2672+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2673+ }
2674+ try self.init(data: data)
2675+ }
2676+
2677+ init(fromURL url: URL) throws {
2678+ try self.init(data: try Data(contentsOf: url))
2679+ }
2680+
2681+ func with(
2682+ apperceptive: String? = nil,
2683+ cuttoo: String? = nil,
2684+ douser: String? = nil,
2685+ drinkproof: String? = nil,
2686+ forementioned: String? = nil,
2687+ freesia: String? = nil,
2688+ genevieve: String? = nil,
2689+ hyperdiabolical: String? = nil,
2690+ hypocone: String? = nil,
2691+ irreverentially: String? = nil,
2692+ jumart: String? = nil,
2693+ mimosaceae: String? = nil,
2694+ mollicrush: String? = nil,
2695+ nedder: String? = nil,
2696+ retinasphalt: String? = nil,
2697+ sough: String? = nil,
2698+ steading: String? = nil,
2699+ theopaschitism: String? = nil,
2700+ undurableness: String? = nil,
2701+ unmingleable: String? = nil
2702+ ) -> TopLevel.Ressaut {
2703+ return TopLevel.Ressaut(
2704+ apperceptive: apperceptive ?? self.apperceptive,
2705+ cuttoo: cuttoo ?? self.cuttoo,
2706+ douser: douser ?? self.douser,
2707+ drinkproof: drinkproof ?? self.drinkproof,
2708+ forementioned: forementioned ?? self.forementioned,
2709+ freesia: freesia ?? self.freesia,
2710+ genevieve: genevieve ?? self.genevieve,
2711+ hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical,
2712+ hypocone: hypocone ?? self.hypocone,
2713+ irreverentially: irreverentially ?? self.irreverentially,
2714+ jumart: jumart ?? self.jumart,
2715+ mimosaceae: mimosaceae ?? self.mimosaceae,
2716+ mollicrush: mollicrush ?? self.mollicrush,
2717+ nedder: nedder ?? self.nedder,
2718+ retinasphalt: retinasphalt ?? self.retinasphalt,
2719+ sough: sough ?? self.sough,
2720+ steading: steading ?? self.steading,
2721+ theopaschitism: theopaschitism ?? self.theopaschitism,
2722+ undurableness: undurableness ?? self.undurableness,
2723+ unmingleable: unmingleable ?? self.unmingleable
2724+ )
2725+ }
2726+
2727+ func jsonData() throws -> Data {
2728+ return try TopLevel.newJSONEncoder().encode(self)
2729+ }
2730+
2731+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2732+ return String(data: try self.jsonData(), encoding: encoding)
2733+ }
2734+}
2735+
2736+extension TopLevel.RewriteClass {
2737+ init(data: Data) throws {
2738+ self = try TopLevel.newJSONDecoder().decode(TopLevel.RewriteClass.self, from: data)
2739+ }
2740+
2741+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2742+ guard let data = json.data(using: encoding) else {
2743+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2744+ }
2745+ try self.init(data: data)
2746+ }
2747+
2748+ init(fromURL url: URL) throws {
2749+ try self.init(data: try Data(contentsOf: url))
2750+ }
2751+
2752+ func with(
2753+ accountancy: JSONNull?? = nil,
2754+ cacotrophic: JSONNull?? = nil,
2755+ contest: JSONNull?? = nil,
2756+ couthily: JSONNull?? = nil,
2757+ falculate: JSONNull?? = nil,
2758+ foreseize: JSONNull?? = nil,
2759+ hyades: JSONNull?? = nil,
2760+ lemnad: JSONNull?? = nil,
2761+ monotheistically: JSONNull?? = nil,
2762+ nonflying: JSONNull?? = nil,
2763+ ptenoglossa: JSONNull?? = nil,
2764+ repatch: JSONNull?? = nil,
2765+ rodman: JSONNull?? = nil,
2766+ strung: JSONNull?? = nil,
2767+ titmal: JSONNull?? = nil,
2768+ twalpennyworth: JSONNull?? = nil,
2769+ unblamable: JSONNull?? = nil,
2770+ vertical: JSONNull?? = nil,
2771+ whiggification: JSONNull?? = nil,
2772+ yardman: JSONNull?? = nil
2773+ ) -> TopLevel.RewriteClass {
2774+ return TopLevel.RewriteClass(
2775+ accountancy: accountancy ?? self.accountancy,
2776+ cacotrophic: cacotrophic ?? self.cacotrophic,
2777+ contest: contest ?? self.contest,
2778+ couthily: couthily ?? self.couthily,
2779+ falculate: falculate ?? self.falculate,
2780+ foreseize: foreseize ?? self.foreseize,
2781+ hyades: hyades ?? self.hyades,
2782+ lemnad: lemnad ?? self.lemnad,
2783+ monotheistically: monotheistically ?? self.monotheistically,
2784+ nonflying: nonflying ?? self.nonflying,
2785+ ptenoglossa: ptenoglossa ?? self.ptenoglossa,
2786+ repatch: repatch ?? self.repatch,
2787+ rodman: rodman ?? self.rodman,
2788+ strung: strung ?? self.strung,
2789+ titmal: titmal ?? self.titmal,
2790+ twalpennyworth: twalpennyworth ?? self.twalpennyworth,
2791+ unblamable: unblamable ?? self.unblamable,
2792+ vertical: vertical ?? self.vertical,
2793+ whiggification: whiggification ?? self.whiggification,
2794+ yardman: yardman ?? self.yardman
2795+ )
2796+ }
2797+
2798+ func jsonData() throws -> Data {
2799+ return try TopLevel.newJSONEncoder().encode(self)
2800+ }
2801+
2802+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2803+ return String(data: try self.jsonData(), encoding: encoding)
2804+ }
2805+}
2806+
2807+extension TopLevel.SantirClass {
2808+ init(data: Data) throws {
2809+ self = try TopLevel.newJSONDecoder().decode(TopLevel.SantirClass.self, from: data)
2810+ }
2811+
2812+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2813+ guard let data = json.data(using: encoding) else {
2814+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2815+ }
2816+ try self.init(data: data)
2817+ }
2818+
2819+ init(fromURL url: URL) throws {
2820+ try self.init(data: try Data(contentsOf: url))
2821+ }
2822+
2823+ func with(
2824+ admiredly: JSONNull?? = nil,
2825+ demicaponier: JSONNull?? = nil,
2826+ epitympanic: JSONNull?? = nil,
2827+ investitor: JSONNull?? = nil,
2828+ lupiform: JSONNull?? = nil,
2829+ monoflagellate: JSONNull?? = nil,
2830+ paleoethnic: JSONNull?? = nil,
2831+ prediscountable: JSONNull?? = nil,
2832+ rhetoricals: JSONNull?? = nil,
2833+ roomth: JSONNull?? = nil,
2834+ saccharose: JSONNull?? = nil,
2835+ septonasal: JSONNull?? = nil,
2836+ serpenticide: JSONNull?? = nil,
2837+ setarious: JSONNull?? = nil,
2838+ spaework: JSONNull?? = nil,
2839+ stylite: JSONNull?? = nil,
2840+ suessiones: JSONNull?? = nil,
2841+ timelily: JSONNull?? = nil,
2842+ unprofaned: JSONNull?? = nil,
2843+ vorticular: JSONNull?? = nil
2844+ ) -> TopLevel.SantirClass {
2845+ return TopLevel.SantirClass(
2846+ admiredly: admiredly ?? self.admiredly,
2847+ demicaponier: demicaponier ?? self.demicaponier,
2848+ epitympanic: epitympanic ?? self.epitympanic,
2849+ investitor: investitor ?? self.investitor,
2850+ lupiform: lupiform ?? self.lupiform,
2851+ monoflagellate: monoflagellate ?? self.monoflagellate,
2852+ paleoethnic: paleoethnic ?? self.paleoethnic,
2853+ prediscountable: prediscountable ?? self.prediscountable,
2854+ rhetoricals: rhetoricals ?? self.rhetoricals,
2855+ roomth: roomth ?? self.roomth,
2856+ saccharose: saccharose ?? self.saccharose,
2857+ septonasal: septonasal ?? self.septonasal,
2858+ serpenticide: serpenticide ?? self.serpenticide,
2859+ setarious: setarious ?? self.setarious,
2860+ spaework: spaework ?? self.spaework,
2861+ stylite: stylite ?? self.stylite,
2862+ suessiones: suessiones ?? self.suessiones,
2863+ timelily: timelily ?? self.timelily,
2864+ unprofaned: unprofaned ?? self.unprofaned,
2865+ vorticular: vorticular ?? self.vorticular
2866+ )
2867+ }
2868+
2869+ func jsonData() throws -> Data {
2870+ return try TopLevel.newJSONEncoder().encode(self)
2871+ }
2872+
2873+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2874+ return String(data: try self.jsonData(), encoding: encoding)
2875+ }
2876+}
2877+
2878+extension TopLevel.SaxtenClass {
2879+ init(data: Data) throws {
2880+ self = try TopLevel.newJSONDecoder().decode(TopLevel.SaxtenClass.self, from: data)
2881+ }
2882+
2883+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2884+ guard let data = json.data(using: encoding) else {
2885+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2886+ }
2887+ try self.init(data: data)
2888+ }
2889+
2890+ init(fromURL url: URL) throws {
2891+ try self.init(data: try Data(contentsOf: url))
2892+ }
2893+
2894+ func with(
2895+ algarrobilla: JSONNull?? = nil,
2896+ bowgrace: JSONNull?? = nil,
2897+ catharticalness: Double?? = nil,
2898+ centaurid: JSONNull?? = nil,
2899+ chirotherium: Int?? = nil,
2900+ disdiapason: String?? = nil,
2901+ flix: JSONNull?? = nil,
2902+ germanely: JSONNull?? = nil,
2903+ homocerc: Bool?? = nil,
2904+ inhume: JSONNull?? = nil,
2905+ lepidote: JSONNull?? = nil,
2906+ megalochirous: JSONNull?? = nil,
2907+ ninepenny: JSONNull?? = nil,
2908+ nonbookish: JSONNull?? = nil,
2909+ nondeist: JSONNull?? = nil,
2910+ nymphaeaceous: JSONNull?? = nil,
2911+ parietofrontal: JSONNull?? = nil,
2912+ sancyite: JSONNull?? = nil,
2913+ subjectivist: JSONNull?? = nil,
2914+ tibiad: JSONNull?? = nil,
2915+ transonic: JSONNull?? = nil,
2916+ tripetalous: JSONNull?? = nil,
2917+ trunchman: JSONNull?? = nil,
2918+ urger: JSONNull?? = nil,
2919+ withdrawnness: JSONNull?? = nil
2920+ ) -> TopLevel.SaxtenClass {
2921+ return TopLevel.SaxtenClass(
2922+ algarrobilla: algarrobilla ?? self.algarrobilla,
2923+ bowgrace: bowgrace ?? self.bowgrace,
2924+ catharticalness: catharticalness ?? self.catharticalness,
2925+ centaurid: centaurid ?? self.centaurid,
2926+ chirotherium: chirotherium ?? self.chirotherium,
2927+ disdiapason: disdiapason ?? self.disdiapason,
2928+ flix: flix ?? self.flix,
2929+ germanely: germanely ?? self.germanely,
2930+ homocerc: homocerc ?? self.homocerc,
2931+ inhume: inhume ?? self.inhume,
2932+ lepidote: lepidote ?? self.lepidote,
2933+ megalochirous: megalochirous ?? self.megalochirous,
2934+ ninepenny: ninepenny ?? self.ninepenny,
2935+ nonbookish: nonbookish ?? self.nonbookish,
2936+ nondeist: nondeist ?? self.nondeist,
2937+ nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous,
2938+ parietofrontal: parietofrontal ?? self.parietofrontal,
2939+ sancyite: sancyite ?? self.sancyite,
2940+ subjectivist: subjectivist ?? self.subjectivist,
2941+ tibiad: tibiad ?? self.tibiad,
2942+ transonic: transonic ?? self.transonic,
2943+ tripetalous: tripetalous ?? self.tripetalous,
2944+ trunchman: trunchman ?? self.trunchman,
2945+ urger: urger ?? self.urger,
2946+ withdrawnness: withdrawnness ?? self.withdrawnness
2947+ )
2948+ }
2949+
2950+ func jsonData() throws -> Data {
2951+ return try TopLevel.newJSONEncoder().encode(self)
2952+ }
2953+
2954+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
2955+ return String(data: try self.jsonData(), encoding: encoding)
2956+ }
2957+}
2958+
2959+extension TopLevel.Scatty {
2960+ init(data: Data) throws {
2961+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Scatty.self, from: data)
2962+ }
2963+
2964+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
2965+ guard let data = json.data(using: encoding) else {
2966+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
2967+ }
2968+ try self.init(data: data)
2969+ }
2970+
2971+ init(fromURL url: URL) throws {
2972+ try self.init(data: try Data(contentsOf: url))
2973+ }
2974+
2975+ func with(
2976+ aeriferous: JSONNull?? = nil,
2977+ antical: JSONNull?? = nil,
2978+ antighostism: JSONNull?? = nil,
2979+ arcanum: JSONNull?? = nil,
2980+ autotrophy: JSONNull?? = nil,
2981+ baronial: JSONNull?? = nil,
2982+ caffeine: JSONNull?? = nil,
2983+ gorgoniacean: JSONNull?? = nil,
2984+ heroical: JSONNull?? = nil,
2985+ hydropical: JSONNull?? = nil,
2986+ mechanology: JSONNull?? = nil,
2987+ musicopoetic: JSONNull?? = nil,
2988+ officiality: JSONNull?? = nil,
2989+ oftentimes: JSONNull?? = nil,
2990+ ophthalmotonometer: JSONNull?? = nil,
2991+ reflectively: JSONNull?? = nil,
2992+ springer: JSONNull?? = nil,
2993+ tabasco: JSONNull?? = nil,
2994+ teleianthous: JSONNull?? = nil,
2995+ uncombated: JSONNull?? = nil
2996+ ) -> TopLevel.Scatty {
2997+ return TopLevel.Scatty(
2998+ aeriferous: aeriferous ?? self.aeriferous,
2999+ antical: antical ?? self.antical,
3000+ antighostism: antighostism ?? self.antighostism,
3001+ arcanum: arcanum ?? self.arcanum,
3002+ autotrophy: autotrophy ?? self.autotrophy,
3003+ baronial: baronial ?? self.baronial,
3004+ caffeine: caffeine ?? self.caffeine,
3005+ gorgoniacean: gorgoniacean ?? self.gorgoniacean,
3006+ heroical: heroical ?? self.heroical,
3007+ hydropical: hydropical ?? self.hydropical,
3008+ mechanology: mechanology ?? self.mechanology,
3009+ musicopoetic: musicopoetic ?? self.musicopoetic,
3010+ officiality: officiality ?? self.officiality,
3011+ oftentimes: oftentimes ?? self.oftentimes,
3012+ ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer,
3013+ reflectively: reflectively ?? self.reflectively,
3014+ springer: springer ?? self.springer,
3015+ tabasco: tabasco ?? self.tabasco,
3016+ teleianthous: teleianthous ?? self.teleianthous,
3017+ uncombated: uncombated ?? self.uncombated
3018+ )
3019+ }
3020+
3021+ func jsonData() throws -> Data {
3022+ return try TopLevel.newJSONEncoder().encode(self)
3023+ }
3024+
3025+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3026+ return String(data: try self.jsonData(), encoding: encoding)
3027+ }
3028+}
3029+
3030+extension TopLevel.SisteringClass {
3031+ init(data: Data) throws {
3032+ self = try TopLevel.newJSONDecoder().decode(TopLevel.SisteringClass.self, from: data)
3033+ }
3034+
3035+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3036+ guard let data = json.data(using: encoding) else {
3037+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3038+ }
3039+ try self.init(data: data)
3040+ }
3041+
3042+ init(fromURL url: URL) throws {
3043+ try self.init(data: try Data(contentsOf: url))
3044+ }
3045+
3046+ func with(
3047+ amphicarpic: JSONNull?? = nil,
3048+ chianti: JSONNull?? = nil,
3049+ frigorific: JSONNull?? = nil,
3050+ haplomi: JSONNull?? = nil,
3051+ hyperkinesis: JSONNull?? = nil,
3052+ laudable: JSONNull?? = nil,
3053+ madwoman: JSONNull?? = nil,
3054+ maimedly: JSONNull?? = nil,
3055+ micropterygidae: JSONNull?? = nil,
3056+ microrhabdus: JSONNull?? = nil,
3057+ nondense: JSONNull?? = nil,
3058+ phlebemphraxis: JSONNull?? = nil,
3059+ redsear: JSONNull?? = nil,
3060+ schismatical: JSONNull?? = nil,
3061+ tartryl: JSONNull?? = nil,
3062+ unabhorred: JSONNull?? = nil,
3063+ undeliberateness: JSONNull?? = nil,
3064+ unmixable: JSONNull?? = nil,
3065+ untruckling: JSONNull?? = nil,
3066+ vineal: JSONNull?? = nil
3067+ ) -> TopLevel.SisteringClass {
3068+ return TopLevel.SisteringClass(
3069+ amphicarpic: amphicarpic ?? self.amphicarpic,
3070+ chianti: chianti ?? self.chianti,
3071+ frigorific: frigorific ?? self.frigorific,
3072+ haplomi: haplomi ?? self.haplomi,
3073+ hyperkinesis: hyperkinesis ?? self.hyperkinesis,
3074+ laudable: laudable ?? self.laudable,
3075+ madwoman: madwoman ?? self.madwoman,
3076+ maimedly: maimedly ?? self.maimedly,
3077+ micropterygidae: micropterygidae ?? self.micropterygidae,
3078+ microrhabdus: microrhabdus ?? self.microrhabdus,
3079+ nondense: nondense ?? self.nondense,
3080+ phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis,
3081+ redsear: redsear ?? self.redsear,
3082+ schismatical: schismatical ?? self.schismatical,
3083+ tartryl: tartryl ?? self.tartryl,
3084+ unabhorred: unabhorred ?? self.unabhorred,
3085+ undeliberateness: undeliberateness ?? self.undeliberateness,
3086+ unmixable: unmixable ?? self.unmixable,
3087+ untruckling: untruckling ?? self.untruckling,
3088+ vineal: vineal ?? self.vineal
3089+ )
3090+ }
3091+
3092+ func jsonData() throws -> Data {
3093+ return try TopLevel.newJSONEncoder().encode(self)
3094+ }
3095+
3096+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3097+ return String(data: try self.jsonData(), encoding: encoding)
3098+ }
3099+}
3100+
3101+extension TopLevel.Staghunting {
3102+ init(data: Data) throws {
3103+ self = try TopLevel.newJSONDecoder().decode(TopLevel.Staghunting.self, from: data)
3104+ }
3105+
3106+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3107+ guard let data = json.data(using: encoding) else {
3108+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3109+ }
3110+ try self.init(data: data)
3111+ }
3112+
3113+ init(fromURL url: URL) throws {
3114+ try self.init(data: try Data(contentsOf: url))
3115+ }
3116+
3117+ func with(
3118+ calorimetric: Int?? = nil,
3119+ canid: Int?? = nil,
3120+ catharticalness: Double?? = nil,
3121+ chirotherium: Int?? = nil,
3122+ disdiapason: String?? = nil,
3123+ ditriglyphic: Int?? = nil,
3124+ floriferousness: Int?? = nil,
3125+ gamelike: Int?? = nil,
3126+ grig: Int?? = nil,
3127+ homocerc: Bool?? = nil,
3128+ interloan: Int?? = nil,
3129+ lithotomy: Int?? = nil,
3130+ loric: Int?? = nil,
3131+ membranocoriaceous: Int?? = nil,
3132+ membranogenic: Int?? = nil,
3133+ nonbookish: JSONNull?? = nil,
3134+ overtrump: Int?? = nil,
3135+ scotino: Int?? = nil,
3136+ seasonable: Int?? = nil,
3137+ sephen: Int?? = nil,
3138+ stigmarioid: Int?? = nil,
3139+ tired: Int?? = nil,
3140+ trifid: Int?? = nil,
3141+ undefeatedly: Int?? = nil,
3142+ ungirlish: Int?? = nil
3143+ ) -> TopLevel.Staghunting {
3144+ return TopLevel.Staghunting(
3145+ calorimetric: calorimetric ?? self.calorimetric,
3146+ canid: canid ?? self.canid,
3147+ catharticalness: catharticalness ?? self.catharticalness,
3148+ chirotherium: chirotherium ?? self.chirotherium,
3149+ disdiapason: disdiapason ?? self.disdiapason,
3150+ ditriglyphic: ditriglyphic ?? self.ditriglyphic,
3151+ floriferousness: floriferousness ?? self.floriferousness,
3152+ gamelike: gamelike ?? self.gamelike,
3153+ grig: grig ?? self.grig,
3154+ homocerc: homocerc ?? self.homocerc,
3155+ interloan: interloan ?? self.interloan,
3156+ lithotomy: lithotomy ?? self.lithotomy,
3157+ loric: loric ?? self.loric,
3158+ membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous,
3159+ membranogenic: membranogenic ?? self.membranogenic,
3160+ nonbookish: nonbookish ?? self.nonbookish,
3161+ overtrump: overtrump ?? self.overtrump,
3162+ scotino: scotino ?? self.scotino,
3163+ seasonable: seasonable ?? self.seasonable,
3164+ sephen: sephen ?? self.sephen,
3165+ stigmarioid: stigmarioid ?? self.stigmarioid,
3166+ tired: tired ?? self.tired,
3167+ trifid: trifid ?? self.trifid,
3168+ undefeatedly: undefeatedly ?? self.undefeatedly,
3169+ ungirlish: ungirlish ?? self.ungirlish
3170+ )
3171+ }
3172+
3173+ func jsonData() throws -> Data {
3174+ return try TopLevel.newJSONEncoder().encode(self)
3175+ }
3176+
3177+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3178+ return String(data: try self.jsonData(), encoding: encoding)
3179+ }
3180+}
3181+
3182+extension TopLevel.StrenuosityClass {
3183+ init(data: Data) throws {
3184+ self = try TopLevel.newJSONDecoder().decode(TopLevel.StrenuosityClass.self, from: data)
3185+ }
3186+
3187+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3188+ guard let data = json.data(using: encoding) else {
3189+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3190+ }
3191+ try self.init(data: data)
3192+ }
3193+
3194+ init(fromURL url: URL) throws {
3195+ try self.init(data: try Data(contentsOf: url))
3196+ }
3197+
3198+ func with(
3199+ bliss: Int?? = nil,
3200+ buccate: Int?? = nil,
3201+ bulletproof: Int?? = nil,
3202+ catharticalness: Double?? = nil,
3203+ chirotherium: Int?? = nil,
3204+ crumblingness: Int?? = nil,
3205+ disdiapason: String?? = nil,
3206+ engagedly: Int?? = nil,
3207+ fightable: Int?? = nil,
3208+ hoariness: Int?? = nil,
3209+ homocerc: Bool?? = nil,
3210+ hypopodium: Int?? = nil,
3211+ luxurist: Int?? = nil,
3212+ mechanician: Int?? = nil,
3213+ nonbookish: JSONNull?? = nil,
3214+ onopordon: Int?? = nil,
3215+ podgily: Int?? = nil,
3216+ reformableness: Int?? = nil,
3217+ scatterbrains: Int?? = nil,
3218+ seminuria: Int?? = nil,
3219+ sodomite: Int?? = nil,
3220+ tramp: Int?? = nil,
3221+ undueness: Int?? = nil,
3222+ worthily: Int?? = nil,
3223+ yankeeist: Int?? = nil
3224+ ) -> TopLevel.StrenuosityClass {
3225+ return TopLevel.StrenuosityClass(
3226+ bliss: bliss ?? self.bliss,
3227+ buccate: buccate ?? self.buccate,
3228+ bulletproof: bulletproof ?? self.bulletproof,
3229+ catharticalness: catharticalness ?? self.catharticalness,
3230+ chirotherium: chirotherium ?? self.chirotherium,
3231+ crumblingness: crumblingness ?? self.crumblingness,
3232+ disdiapason: disdiapason ?? self.disdiapason,
3233+ engagedly: engagedly ?? self.engagedly,
3234+ fightable: fightable ?? self.fightable,
3235+ hoariness: hoariness ?? self.hoariness,
3236+ homocerc: homocerc ?? self.homocerc,
3237+ hypopodium: hypopodium ?? self.hypopodium,
3238+ luxurist: luxurist ?? self.luxurist,
3239+ mechanician: mechanician ?? self.mechanician,
3240+ nonbookish: nonbookish ?? self.nonbookish,
3241+ onopordon: onopordon ?? self.onopordon,
3242+ podgily: podgily ?? self.podgily,
3243+ reformableness: reformableness ?? self.reformableness,
3244+ scatterbrains: scatterbrains ?? self.scatterbrains,
3245+ seminuria: seminuria ?? self.seminuria,
3246+ sodomite: sodomite ?? self.sodomite,
3247+ tramp: tramp ?? self.tramp,
3248+ undueness: undueness ?? self.undueness,
3249+ worthily: worthily ?? self.worthily,
3250+ yankeeist: yankeeist ?? self.yankeeist
3251+ )
3252+ }
3253+
3254+ func jsonData() throws -> Data {
3255+ return try TopLevel.newJSONEncoder().encode(self)
3256+ }
3257+
3258+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3259+ return String(data: try self.jsonData(), encoding: encoding)
3260+ }
3261+}
3262+
3263+extension TopLevel.TruantcyClass {
3264+ init(data: Data) throws {
3265+ self = try TopLevel.newJSONDecoder().decode(TopLevel.TruantcyClass.self, from: data)
3266+ }
3267+
3268+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3269+ guard let data = json.data(using: encoding) else {
3270+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3271+ }
3272+ try self.init(data: data)
3273+ }
3274+
3275+ init(fromURL url: URL) throws {
3276+ try self.init(data: try Data(contentsOf: url))
3277+ }
3278+
3279+ func with(
3280+ alfiona: JSONNull?? = nil,
3281+ ascaridiasis: JSONNull?? = nil,
3282+ bungey: JSONNull?? = nil,
3283+ catharticalness: Double?? = nil,
3284+ ceroxyle: JSONNull?? = nil,
3285+ chirotherium: Int?? = nil,
3286+ chorology: JSONNull?? = nil,
3287+ disdiapason: String?? = nil,
3288+ enmarble: JSONNull?? = nil,
3289+ epeira: JSONNull?? = nil,
3290+ eurylaimi: JSONNull?? = nil,
3291+ germination: JSONNull?? = nil,
3292+ hallelujah: JSONNull?? = nil,
3293+ homocerc: Bool?? = nil,
3294+ lev: JSONNull?? = nil,
3295+ mouthing: JSONNull?? = nil,
3296+ nonbookish: JSONNull?? = nil,
3297+ philliloo: JSONNull?? = nil,
3298+ planetal: JSONNull?? = nil,
3299+ poney: JSONNull?? = nil,
3300+ punctualist: JSONNull?? = nil,
3301+ returnlessly: JSONNull?? = nil,
3302+ skelder: JSONNull?? = nil,
3303+ windwaywardly: JSONNull?? = nil,
3304+ yuman: JSONNull?? = nil
3305+ ) -> TopLevel.TruantcyClass {
3306+ return TopLevel.TruantcyClass(
3307+ alfiona: alfiona ?? self.alfiona,
3308+ ascaridiasis: ascaridiasis ?? self.ascaridiasis,
3309+ bungey: bungey ?? self.bungey,
3310+ catharticalness: catharticalness ?? self.catharticalness,
3311+ ceroxyle: ceroxyle ?? self.ceroxyle,
3312+ chirotherium: chirotherium ?? self.chirotherium,
3313+ chorology: chorology ?? self.chorology,
3314+ disdiapason: disdiapason ?? self.disdiapason,
3315+ enmarble: enmarble ?? self.enmarble,
3316+ epeira: epeira ?? self.epeira,
3317+ eurylaimi: eurylaimi ?? self.eurylaimi,
3318+ germination: germination ?? self.germination,
3319+ hallelujah: hallelujah ?? self.hallelujah,
3320+ homocerc: homocerc ?? self.homocerc,
3321+ lev: lev ?? self.lev,
3322+ mouthing: mouthing ?? self.mouthing,
3323+ nonbookish: nonbookish ?? self.nonbookish,
3324+ philliloo: philliloo ?? self.philliloo,
3325+ planetal: planetal ?? self.planetal,
3326+ poney: poney ?? self.poney,
3327+ punctualist: punctualist ?? self.punctualist,
3328+ returnlessly: returnlessly ?? self.returnlessly,
3329+ skelder: skelder ?? self.skelder,
3330+ windwaywardly: windwaywardly ?? self.windwaywardly,
3331+ yuman: yuman ?? self.yuman
3332+ )
3333+ }
3334+
3335+ func jsonData() throws -> Data {
3336+ return try TopLevel.newJSONEncoder().encode(self)
3337+ }
3338+
3339+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3340+ return String(data: try self.jsonData(), encoding: encoding)
3341+ }
3342+}
3343+
3344+extension TopLevel.UnimpeachablyClass {
3345+ init(data: Data) throws {
3346+ self = try TopLevel.newJSONDecoder().decode(TopLevel.UnimpeachablyClass.self, from: data)
3347+ }
3348+
3349+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3350+ guard let data = json.data(using: encoding) else {
3351+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3352+ }
3353+ try self.init(data: data)
3354+ }
3355+
3356+ init(fromURL url: URL) throws {
3357+ try self.init(data: try Data(contentsOf: url))
3358+ }
3359+
3360+ func with(
3361+ acerin: Int?? = nil,
3362+ bobadil: Int?? = nil,
3363+ catharticalness: Double?? = nil,
3364+ chirotherium: Int?? = nil,
3365+ chlorophylligenous: Int?? = nil,
3366+ conversational: Int?? = nil,
3367+ demiowl: Int?? = nil,
3368+ disdiapason: String?? = nil,
3369+ ectorhinal: Int?? = nil,
3370+ gamblesomeness: Int?? = nil,
3371+ homocerc: Bool?? = nil,
3372+ irrorate: Int?? = nil,
3373+ kindergartening: Int?? = nil,
3374+ lateritic: Int?? = nil,
3375+ mespil: Int?? = nil,
3376+ misconfiguration: Int?? = nil,
3377+ nonbookish: JSONNull?? = nil,
3378+ planometry: Int?? = nil,
3379+ quiina: Int?? = nil,
3380+ robert: Int?? = nil,
3381+ rot: Int?? = nil,
3382+ subcinctorium: Int?? = nil,
3383+ tussocker: Int?? = nil,
3384+ ultraproud: Int?? = nil,
3385+ unsuggestedness: Int?? = nil
3386+ ) -> TopLevel.UnimpeachablyClass {
3387+ return TopLevel.UnimpeachablyClass(
3388+ acerin: acerin ?? self.acerin,
3389+ bobadil: bobadil ?? self.bobadil,
3390+ catharticalness: catharticalness ?? self.catharticalness,
3391+ chirotherium: chirotherium ?? self.chirotherium,
3392+ chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous,
3393+ conversational: conversational ?? self.conversational,
3394+ demiowl: demiowl ?? self.demiowl,
3395+ disdiapason: disdiapason ?? self.disdiapason,
3396+ ectorhinal: ectorhinal ?? self.ectorhinal,
3397+ gamblesomeness: gamblesomeness ?? self.gamblesomeness,
3398+ homocerc: homocerc ?? self.homocerc,
3399+ irrorate: irrorate ?? self.irrorate,
3400+ kindergartening: kindergartening ?? self.kindergartening,
3401+ lateritic: lateritic ?? self.lateritic,
3402+ mespil: mespil ?? self.mespil,
3403+ misconfiguration: misconfiguration ?? self.misconfiguration,
3404+ nonbookish: nonbookish ?? self.nonbookish,
3405+ planometry: planometry ?? self.planometry,
3406+ quiina: quiina ?? self.quiina,
3407+ robert: robert ?? self.robert,
3408+ rot: rot ?? self.rot,
3409+ subcinctorium: subcinctorium ?? self.subcinctorium,
3410+ tussocker: tussocker ?? self.tussocker,
3411+ ultraproud: ultraproud ?? self.ultraproud,
3412+ unsuggestedness: unsuggestedness ?? self.unsuggestedness
3413+ )
3414+ }
3415+
3416+ func jsonData() throws -> Data {
3417+ return try TopLevel.newJSONEncoder().encode(self)
3418+ }
3419+
3420+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3421+ return String(data: try self.jsonData(), encoding: encoding)
3422+ }
3423+}
3424+
3425+extension TopLevel.UnstressedClass {
3426+ init(data: Data) throws {
3427+ self = try TopLevel.newJSONDecoder().decode(TopLevel.UnstressedClass.self, from: data)
3428+ }
3429+
3430+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3431+ guard let data = json.data(using: encoding) else {
3432+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3433+ }
3434+ try self.init(data: data)
3435+ }
3436+
3437+ init(fromURL url: URL) throws {
3438+ try self.init(data: try Data(contentsOf: url))
3439+ }
3440+
3441+ func with(
3442+ alain: JSONNull?? = nil,
3443+ amphirhina: JSONNull?? = nil,
3444+ antimachinery: JSONNull?? = nil,
3445+ coldish: JSONNull?? = nil,
3446+ crantara: JSONNull?? = nil,
3447+ distinguishing: JSONNull?? = nil,
3448+ elytroposis: JSONNull?? = nil,
3449+ gentianwort: JSONNull?? = nil,
3450+ heliosis: JSONNull?? = nil,
3451+ instrumental: JSONNull?? = nil,
3452+ introinflection: JSONNull?? = nil,
3453+ kala: JSONNull?? = nil,
3454+ lincolnian: JSONNull?? = nil,
3455+ metad: JSONNull?? = nil,
3456+ sarcophilus: JSONNull?? = nil,
3457+ swingingly: JSONNull?? = nil,
3458+ unconformity: JSONNull?? = nil,
3459+ undecreed: JSONNull?? = nil,
3460+ venerable: JSONNull?? = nil,
3461+ vowellessness: JSONNull?? = nil
3462+ ) -> TopLevel.UnstressedClass {
3463+ return TopLevel.UnstressedClass(
3464+ alain: alain ?? self.alain,
3465+ amphirhina: amphirhina ?? self.amphirhina,
3466+ antimachinery: antimachinery ?? self.antimachinery,
3467+ coldish: coldish ?? self.coldish,
3468+ crantara: crantara ?? self.crantara,
3469+ distinguishing: distinguishing ?? self.distinguishing,
3470+ elytroposis: elytroposis ?? self.elytroposis,
3471+ gentianwort: gentianwort ?? self.gentianwort,
3472+ heliosis: heliosis ?? self.heliosis,
3473+ instrumental: instrumental ?? self.instrumental,
3474+ introinflection: introinflection ?? self.introinflection,
3475+ kala: kala ?? self.kala,
3476+ lincolnian: lincolnian ?? self.lincolnian,
3477+ metad: metad ?? self.metad,
3478+ sarcophilus: sarcophilus ?? self.sarcophilus,
3479+ swingingly: swingingly ?? self.swingingly,
3480+ unconformity: unconformity ?? self.unconformity,
3481+ undecreed: undecreed ?? self.undecreed,
3482+ venerable: venerable ?? self.venerable,
3483+ vowellessness: vowellessness ?? self.vowellessness
3484+ )
3485+ }
3486+
3487+ func jsonData() throws -> Data {
3488+ return try TopLevel.newJSONEncoder().encode(self)
3489+ }
3490+
3491+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3492+ return String(data: try self.jsonData(), encoding: encoding)
3493+ }
3494+}
3495+
3496+extension TopLevel.WrothyClass {
3497+ init(data: Data) throws {
3498+ self = try TopLevel.newJSONDecoder().decode(TopLevel.WrothyClass.self, from: data)
3499+ }
3500+
3501+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
3502+ guard let data = json.data(using: encoding) else {
3503+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
3504+ }
3505+ try self.init(data: data)
3506+ }
3507+
3508+ init(fromURL url: URL) throws {
3509+ try self.init(data: try Data(contentsOf: url))
3510+ }
3511+
3512+ func with(
3513+ aeschynanthus: JSONNull?? = nil,
3514+ aquiferous: JSONNull?? = nil,
3515+ cheapener: JSONNull?? = nil,
3516+ enumeration: JSONNull?? = nil,
3517+ ephesine: JSONNull?? = nil,
3518+ escadrille: JSONNull?? = nil,
3519+ estrous: JSONNull?? = nil,
3520+ interestedly: JSONNull?? = nil,
3521+ katakinetomer: JSONNull?? = nil,
3522+ mortification: JSONNull?? = nil,
3523+ morula: JSONNull?? = nil,
3524+ orthosymmetrical: JSONNull?? = nil,
3525+ overbark: JSONNull?? = nil,
3526+ politist: JSONNull?? = nil,
3527+ qualified: JSONNull?? = nil,
3528+ sphenomalar: JSONNull?? = nil,
3529+ throatful: JSONNull?? = nil,
3530+ transhumance: JSONNull?? = nil,
3531+ triandrian: JSONNull?? = nil,
3532+ unbooked: JSONNull?? = nil
3533+ ) -> TopLevel.WrothyClass {
3534+ return TopLevel.WrothyClass(
3535+ aeschynanthus: aeschynanthus ?? self.aeschynanthus,
3536+ aquiferous: aquiferous ?? self.aquiferous,
3537+ cheapener: cheapener ?? self.cheapener,
3538+ enumeration: enumeration ?? self.enumeration,
3539+ ephesine: ephesine ?? self.ephesine,
3540+ escadrille: escadrille ?? self.escadrille,
3541+ estrous: estrous ?? self.estrous,
3542+ interestedly: interestedly ?? self.interestedly,
3543+ katakinetomer: katakinetomer ?? self.katakinetomer,
3544+ mortification: mortification ?? self.mortification,
3545+ morula: morula ?? self.morula,
3546+ orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical,
3547+ overbark: overbark ?? self.overbark,
3548+ politist: politist ?? self.politist,
3549+ qualified: qualified ?? self.qualified,
3550+ sphenomalar: sphenomalar ?? self.sphenomalar,
3551+ throatful: throatful ?? self.throatful,
3552+ transhumance: transhumance ?? self.transhumance,
3553+ triandrian: triandrian ?? self.triandrian,
3554+ unbooked: unbooked ?? self.unbooked
3555+ )
3556+ }
3557+
3558+ func jsonData() throws -> Data {
3559+ return try TopLevel.newJSONEncoder().encode(self)
3560+ }
3561+
3562+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
3563+ return String(data: try self.jsonData(), encoding: encoding)
3564+ }
3565+}
3566+
3567+// MARK: - Encode/decode helpers
3568+
3569+class JSONNull: Codable, Hashable {
3570+
3571+ public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
3572+ return true
3573+ }
3574+
3575+ public func hash(into hasher: inout Hasher) {
3576+ hasher.combine(0)
3577+ }
3578+
3579+ public init() {}
3580+
3581+ public required init(from decoder: Decoder) throws {
3582+ let container = try decoder.singleValueContainer()
3583+ if !container.decodeNil() {
3584+ throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
3585+ }
3586+ }
3587+
3588+ public func encode(to encoder: Encoder) throws {
3589+ var container = encoder.singleValueContainer()
3590+ try container.encodeNil()
3591+ }
3592+}
Test case

test/inputs/schema/coding-keys.schema

37 generated files · +2,836 −0
Aschema-cjsondefault / TopLevel.c+145 −0
@@ -0,0 +1,145 @@
1+/**
2+ * TopLevel.c
3+ * This file has been autogenerated using quicktype https://github.com/quicktype/quicktype - DO NOT EDIT
4+ */
5+
6+#include "TopLevel.h"
7+
8+struct CodingKeys * cJSON_ParseCodingKeys(const char * s) {
9+ struct CodingKeys * x = NULL;
10+ if (NULL != s) {
11+ cJSON * j = cJSON_Parse(s);
12+ if (NULL != j) {
13+ x = cJSON_GetCodingKeysValue(j);
14+ cJSON_Delete(j);
15+ }
16+ }
17+ return x;
18+}
19+
20+struct CodingKeys * cJSON_GetCodingKeysValue(const cJSON * j) {
21+ struct CodingKeys * x = NULL;
22+ if (NULL != j) {
23+ if (NULL != (x = cJSON_malloc(sizeof(struct CodingKeys)))) {
24+ memset(x, 0, sizeof(struct CodingKeys));
25+ if (cJSON_HasObjectItem(j, "foo")) {
26+ x->foo = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "foo")));
27+ }
28+ else {
29+ if (NULL != (x->foo = cJSON_malloc(sizeof(char)))) {
30+ x->foo[0] = '\0';
31+ }
32+ }
33+ }
34+ }
35+ return x;
36+}
37+
38+cJSON * cJSON_CreateCodingKeys(const struct CodingKeys * x) {
39+ cJSON * j = NULL;
40+ if (NULL != x) {
41+ if (NULL != (j = cJSON_CreateObject())) {
42+ if (NULL != x->foo) {
43+ cJSON_AddStringToObject(j, "foo", x->foo);
44+ }
45+ else {
46+ cJSON_AddStringToObject(j, "foo", "");
47+ }
48+ }
49+ }
50+ return j;
51+}
52+
53+char * cJSON_PrintCodingKeys(const struct CodingKeys * x) {
54+ char * s = NULL;
55+ if (NULL != x) {
56+ cJSON * j = cJSON_CreateCodingKeys(x);
57+ if (NULL != j) {
58+ s = cJSON_Print(j);
59+ cJSON_Delete(j);
60+ }
61+ }
62+ return s;
63+}
64+
65+void cJSON_DeleteCodingKeys(struct CodingKeys * x) {
66+ if (NULL != x) {
67+ if (NULL != x->foo) {
68+ cJSON_free(x->foo);
69+ }
70+ cJSON_free(x);
71+ }
72+}
73+
74+struct TopLevel * cJSON_ParseTopLevel(const char * s) {
75+ struct TopLevel * x = NULL;
76+ if (NULL != s) {
77+ cJSON * j = cJSON_Parse(s);
78+ if (NULL != j) {
79+ x = cJSON_GetTopLevelValue(j);
80+ cJSON_Delete(j);
81+ }
82+ }
83+ return x;
84+}
85+
86+struct TopLevel * cJSON_GetTopLevelValue(const cJSON * j) {
87+ struct TopLevel * x = NULL;
88+ if (NULL != j) {
89+ if (NULL != (x = cJSON_malloc(sizeof(struct TopLevel)))) {
90+ memset(x, 0, sizeof(struct TopLevel));
91+ if (cJSON_HasObjectItem(j, "coding-keys")) {
92+ x->coding_keys = cJSON_GetCodingKeysValue(cJSON_GetObjectItemCaseSensitive(j, "coding-keys"));
93+ }
94+ if (cJSON_HasObjectItem(j, "name")) {
95+ x->name = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "name")));
96+ }
97+ else {
98+ if (NULL != (x->name = cJSON_malloc(sizeof(char)))) {
99+ x->name[0] = '\0';
100+ }
101+ }
102+ }
103+ }
104+ return x;
105+}
106+
107+cJSON * cJSON_CreateTopLevel(const struct TopLevel * x) {
108+ cJSON * j = NULL;
109+ if (NULL != x) {
110+ if (NULL != (j = cJSON_CreateObject())) {
111+ cJSON_AddItemToObject(j, "coding-keys", cJSON_CreateCodingKeys(x->coding_keys));
112+ if (NULL != x->name) {
113+ cJSON_AddStringToObject(j, "name", x->name);
114+ }
115+ else {
116+ cJSON_AddStringToObject(j, "name", "");
117+ }
118+ }
119+ }
120+ return j;
121+}
122+
123+char * cJSON_PrintTopLevel(const struct TopLevel * x) {
124+ char * s = NULL;
125+ if (NULL != x) {
126+ cJSON * j = cJSON_CreateTopLevel(x);
127+ if (NULL != j) {
128+ s = cJSON_Print(j);
129+ cJSON_Delete(j);
130+ }
131+ }
132+ return s;
133+}
134+
135+void cJSON_DeleteTopLevel(struct TopLevel * x) {
136+ if (NULL != x) {
137+ if (NULL != x->coding_keys) {
138+ cJSON_DeleteCodingKeys(x->coding_keys);
139+ }
140+ if (NULL != x->name) {
141+ cJSON_free(x->name);
142+ }
143+ cJSON_free(x);
144+ }
145+}
Aschema-cjsondefault / TopLevel.h+62 −0
@@ -0,0 +1,62 @@
1+/**
2+ * TopLevel.h
3+ * This file has been autogenerated using quicktype https://github.com/quicktype/quicktype - DO NOT EDIT
4+ * This file depends of https://github.com/DaveGamble/cJSON, https://github.com/joelguittet/c-list and https://github.com/joelguittet/c-hashtable
5+ * To parse json data from json string use the following: struct <type> * data = cJSON_Parse<type>(<string>);
6+ * To get json data from cJSON object use the following: struct <type> * data = cJSON_Get<type>Value(<cjson>);
7+ * To get cJSON object from json data use the following: cJSON * cjson = cJSON_Create<type>(<data>);
8+ * To print json string from json data use the following: char * string = cJSON_Print<type>(<data>);
9+ * To delete json data use the following: cJSON_Delete<type>(<data>);
10+ */
11+
12+#ifndef __TOPLEVEL_H__
13+#define __TOPLEVEL_H__
14+
15+#ifdef __cplusplus
16+extern "C" {
17+#endif
18+
19+#include <stdint.h>
20+#include <stdbool.h>
21+#include <stdlib.h>
22+#include <string.h>
23+#include <cJSON.h>
24+#include <hashtable.h>
25+#include <list.h>
26+
27+#ifndef cJSON_Bool
28+#define cJSON_Bool (cJSON_True | cJSON_False)
29+#endif
30+#ifndef cJSON_Map
31+#define cJSON_Map (1 << 16)
32+#endif
33+#ifndef cJSON_Enum
34+#define cJSON_Enum (1 << 17)
35+#endif
36+
37+struct CodingKeys {
38+ char * foo;
39+};
40+
41+struct TopLevel {
42+ struct CodingKeys * coding_keys;
43+ char * name;
44+};
45+
46+struct CodingKeys * cJSON_ParseCodingKeys(const char * s);
47+struct CodingKeys * cJSON_GetCodingKeysValue(const cJSON * j);
48+cJSON * cJSON_CreateCodingKeys(const struct CodingKeys * x);
49+char * cJSON_PrintCodingKeys(const struct CodingKeys * x);
50+void cJSON_DeleteCodingKeys(struct CodingKeys * x);
51+
52+struct TopLevel * cJSON_ParseTopLevel(const char * s);
53+struct TopLevel * cJSON_GetTopLevelValue(const cJSON * j);
54+cJSON * cJSON_CreateTopLevel(const struct TopLevel * x);
55+char * cJSON_PrintTopLevel(const struct TopLevel * x);
56+void cJSON_DeleteTopLevel(struct TopLevel * x);
57+
58+#ifdef __cplusplus
59+}
60+#endif
61+
62+#endif /* __TOPLEVEL_H__ */
Aschema-cplusplusdefault / quicktype.hpp+94 −0
@@ -0,0 +1,94 @@
1+// To parse this JSON data, first install
2+//
3+// json.hpp https://github.com/nlohmann/json
4+//
5+// Then include this file, and then do
6+//
7+// TopLevel data = nlohmann::json::parse(jsonString);
8+
9+#pragma once
10+
11+#include "json.hpp"
12+
13+#include <optional>
14+#include <stdexcept>
15+#include <regex>
16+
17+namespace quicktype {
18+ using nlohmann::json;
19+
20+ #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
21+ #define NLOHMANN_UNTYPED_quicktype_HELPER
22+ inline json get_untyped(const json & j, const char * property) {
23+ if (j.find(property) != j.end()) {
24+ return j.at(property).get<json>();
25+ }
26+ return json();
27+ }
28+
29+ inline json get_untyped(const json & j, std::string property) {
30+ return get_untyped(j, property.data());
31+ }
32+ #endif
33+
34+ class CodingKeys {
35+ public:
36+ CodingKeys() = default;
37+ virtual ~CodingKeys() = default;
38+
39+ private:
40+ std::string foo;
41+
42+ public:
43+ const std::string & get_foo() const { return foo; }
44+ std::string & get_mutable_foo() { return foo; }
45+ void set_foo(const std::string & value) { this->foo = value; }
46+ };
47+
48+ class TopLevel {
49+ public:
50+ TopLevel() = default;
51+ virtual ~TopLevel() = default;
52+
53+ private:
54+ CodingKeys coding_keys;
55+ std::string name;
56+
57+ public:
58+ const CodingKeys & get_coding_keys() const { return coding_keys; }
59+ CodingKeys & get_mutable_coding_keys() { return coding_keys; }
60+ void set_coding_keys(const CodingKeys & value) { this->coding_keys = value; }
61+
62+ const std::string & get_name() const { return name; }
63+ std::string & get_mutable_name() { return name; }
64+ void set_name(const std::string & value) { this->name = value; }
65+ };
66+}
67+
68+namespace quicktype {
69+ void from_json(const json & j, CodingKeys & x);
70+ void to_json(json & j, const CodingKeys & x);
71+
72+ void from_json(const json & j, TopLevel & x);
73+ void to_json(json & j, const TopLevel & x);
74+
75+ inline void from_json(const json & j, CodingKeys& x) {
76+ x.set_foo(j.at("foo").get<std::string>());
77+ }
78+
79+ inline void to_json(json & j, const CodingKeys & x) {
80+ j = json::object();
81+ j["foo"] = x.get_foo();
82+ }
83+
84+ inline void from_json(const json & j, TopLevel& x) {
85+ x.set_coding_keys(j.at("coding-keys").get<CodingKeys>());
86+ x.set_name(j.at("name").get<std::string>());
87+ }
88+
89+ inline void to_json(json & j, const TopLevel & x) {
90+ j = json::object();
91+ j["coding-keys"] = x.get_coding_keys();
92+ j["name"] = x.get_name();
93+ }
94+}
Aschema-csharp-recordsdefault / QuickType.cs+70 −0
@@ -0,0 +1,70 @@
1+// <auto-generated />
2+//
3+// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
4+//
5+// using QuickType;
6+//
7+// var topLevel = TopLevel.FromJson(jsonString);
8+#nullable enable
9+#pragma warning disable CS8618
10+#pragma warning disable CS8601
11+#pragma warning disable CS8602
12+#pragma warning disable CS8603
13+#pragma warning disable CS8604
14+#pragma warning disable CS8625
15+#pragma warning disable CS8765
16+
17+namespace QuickType
18+{
19+ using System;
20+ using System.Collections.Generic;
21+
22+ using System.Globalization;
23+ using Newtonsoft.Json;
24+ using Newtonsoft.Json.Converters;
25+
26+ public partial record TopLevel
27+ {
28+ [JsonProperty("coding-keys", Required = Required.Always)]
29+ public CodingKeys CodingKeys { get; set; }
30+
31+ [JsonProperty("name", Required = Required.Always)]
32+ public string Name { get; set; }
33+ }
34+
35+ public partial record CodingKeys
36+ {
37+ [JsonProperty("foo", Required = Required.Always)]
38+ public string Foo { get; set; }
39+ }
40+
41+ public partial record TopLevel
42+ {
43+ public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject<TopLevel>(json, QuickType.Converter.Settings);
44+ }
45+
46+ public static partial class Serialize
47+ {
48+ public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
49+ }
50+
51+ internal static partial class Converter
52+ {
53+ public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
54+ {
55+ MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
56+ DateParseHandling = DateParseHandling.None,
57+ Converters =
58+ {
59+ new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
60+ },
61+ };
62+ }
63+}
64+#pragma warning restore CS8618
65+#pragma warning restore CS8601
66+#pragma warning restore CS8602
67+#pragma warning restore CS8603
68+#pragma warning restore CS8604
69+#pragma warning restore CS8625
70+#pragma warning restore CS8765
Aschema-csharp-SystemTextJsondefault / QuickType.cs+177 −0
@@ -0,0 +1,177 @@
1+// <auto-generated />
2+//
3+// To parse this JSON data, add NuGet 'System.Text.Json' then do:
4+//
5+// using QuickType;
6+//
7+// var topLevel = TopLevel.FromJson(jsonString);
8+#nullable enable
9+#pragma warning disable CS8618
10+#pragma warning disable CS8601
11+#pragma warning disable CS8602
12+#pragma warning disable CS8603
13+
14+namespace QuickType
15+{
16+ using System;
17+ using System.Collections.Generic;
18+
19+ using System.Text.Json;
20+ using System.Text.Json.Serialization;
21+ using System.Globalization;
22+
23+ public partial class TopLevel
24+ {
25+ [JsonRequired]
26+ [JsonPropertyName("coding-keys")]
27+ public CodingKeys CodingKeys { get; set; }
28+
29+ [JsonRequired]
30+ [JsonPropertyName("name")]
31+ public string Name { get; set; }
32+ }
33+
34+ public partial class CodingKeys
35+ {
36+ [JsonRequired]
37+ [JsonPropertyName("foo")]
38+ public string Foo { get; set; }
39+ }
40+
41+ public partial class TopLevel
42+ {
43+ public static TopLevel FromJson(string json) => JsonSerializer.Deserialize<TopLevel>(json, QuickType.Converter.Settings);
44+ }
45+
46+ public static partial class Serialize
47+ {
48+ public static string ToJson(this TopLevel self) => JsonSerializer.Serialize(self, QuickType.Converter.Settings);
49+ }
50+
51+ internal static partial class Converter
52+ {
53+ public static readonly JsonSerializerOptions Settings = new(JsonSerializerDefaults.General)
54+ {
55+ Converters =
56+ {
57+ new DateOnlyConverter(),
58+ new TimeOnlyConverter(),
59+ IsoDateTimeOffsetConverter.Singleton
60+ },
61+ };
62+ }
63+
64+ public class DateOnlyConverter : JsonConverter<DateOnly>
65+ {
66+ private readonly string serializationFormat;
67+ public DateOnlyConverter() : this(null) { }
68+
69+ public DateOnlyConverter(string? serializationFormat)
70+ {
71+ this.serializationFormat = serializationFormat ?? "yyyy-MM-dd";
72+ }
73+
74+ public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
75+ {
76+ var value = reader.GetString();
77+ return DateOnly.Parse(value!);
78+ }
79+
80+ public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options)
81+ => writer.WriteStringValue(value.ToString(serializationFormat));
82+ }
83+
84+ public class TimeOnlyConverter : JsonConverter<TimeOnly>
85+ {
86+ private readonly string serializationFormat;
87+
88+ public TimeOnlyConverter() : this(null) { }
89+
90+ public TimeOnlyConverter(string? serializationFormat)
91+ {
92+ this.serializationFormat = serializationFormat ?? "HH:mm:ss.fff";
93+ }
94+
95+ public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
96+ {
97+ var value = reader.GetString();
98+ return TimeOnly.Parse(value!);
99+ }
100+
101+ public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
102+ => writer.WriteStringValue(value.ToString(serializationFormat));
103+ }
104+
105+ internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
106+ {
107+ public override bool CanConvert(Type t) => t == typeof(DateTimeOffset);
108+
109+ private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
110+
111+ private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind;
112+ private string? _dateTimeFormat;
113+ private CultureInfo? _culture;
114+
115+ public DateTimeStyles DateTimeStyles
116+ {
117+ get => _dateTimeStyles;
118+ set => _dateTimeStyles = value;
119+ }
120+
121+ public string? DateTimeFormat
122+ {
123+ get => _dateTimeFormat ?? string.Empty;
124+ set => _dateTimeFormat = (string.IsNullOrEmpty(value)) ? null : value;
125+ }
126+
127+ public CultureInfo Culture
128+ {
129+ get => _culture ?? CultureInfo.CurrentCulture;
130+ set => _culture = value;
131+ }
132+
133+ public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options)
134+ {
135+ string text;
136+
137+
138+ if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
139+ || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
140+ {
141+ value = value.ToUniversalTime();
142+ }
143+
144+ text = value.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
145+
146+ writer.WriteStringValue(text);
147+ }
148+
149+ public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
150+ {
151+ string? dateText = reader.GetString();
152+
153+ if (string.IsNullOrEmpty(dateText) == false)
154+ {
155+ if (!string.IsNullOrEmpty(_dateTimeFormat))
156+ {
157+ return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
158+ }
159+ else
160+ {
161+ return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles);
162+ }
163+ }
164+ else
165+ {
166+ return default(DateTimeOffset);
167+ }
168+ }
169+
170+
171+ public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter();
172+ }
173+}
174+#pragma warning restore CS8618
175+#pragma warning restore CS8601
176+#pragma warning restore CS8602
177+#pragma warning restore CS8603
Aschema-csharpdefault / QuickType.cs+70 −0
@@ -0,0 +1,70 @@
1+// <auto-generated />
2+//
3+// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
4+//
5+// using QuickType;
6+//
7+// var topLevel = TopLevel.FromJson(jsonString);
8+#nullable enable
9+#pragma warning disable CS8618
10+#pragma warning disable CS8601
11+#pragma warning disable CS8602
12+#pragma warning disable CS8603
13+#pragma warning disable CS8604
14+#pragma warning disable CS8625
15+#pragma warning disable CS8765
16+
17+namespace QuickType
18+{
19+ using System;
20+ using System.Collections.Generic;
21+
22+ using System.Globalization;
23+ using Newtonsoft.Json;
24+ using Newtonsoft.Json.Converters;
25+
26+ public partial class TopLevel
27+ {
28+ [JsonProperty("coding-keys", Required = Required.Always)]
29+ public CodingKeys CodingKeys { get; set; }
30+
31+ [JsonProperty("name", Required = Required.Always)]
32+ public string Name { get; set; }
33+ }
34+
35+ public partial class CodingKeys
36+ {
37+ [JsonProperty("foo", Required = Required.Always)]
38+ public string Foo { get; set; }
39+ }
40+
41+ public partial class TopLevel
42+ {
43+ public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject<TopLevel>(json, QuickType.Converter.Settings);
44+ }
45+
46+ public static partial class Serialize
47+ {
48+ public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
49+ }
50+
51+ internal static partial class Converter
52+ {
53+ public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
54+ {
55+ MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
56+ DateParseHandling = DateParseHandling.None,
57+ Converters =
58+ {
59+ new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
60+ },
61+ };
62+ }
63+}
64+#pragma warning restore CS8618
65+#pragma warning restore CS8601
66+#pragma warning restore CS8602
67+#pragma warning restore CS8603
68+#pragma warning restore CS8604
69+#pragma warning restore CS8625
70+#pragma warning restore CS8765
Aschema-dartdefault / TopLevel.dart+45 −0
@@ -0,0 +1,45 @@
1+// To parse this JSON data, do
2+//
3+// final topLevel = topLevelFromJson(jsonString);
4+
5+import 'dart:convert';
6+
7+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
8+
9+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
10+
11+class TopLevel {
12+ final CodingKeys codingKeys;
13+ final String name;
14+
15+ TopLevel({
16+ required this.codingKeys,
17+ required this.name,
18+ });
19+
20+ factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
21+ codingKeys: CodingKeys.fromJson(json["coding-keys"]),
22+ name: json["name"],
23+ );
24+
25+ Map<String, dynamic> toJson() => {
26+ "coding-keys": codingKeys.toJson(),
27+ "name": name,
28+ };
29+}
30+
31+class CodingKeys {
32+ final String foo;
33+
34+ CodingKeys({
35+ required this.foo,
36+ });
37+
38+ factory CodingKeys.fromJson(Map<String, dynamic> json) => CodingKeys(
39+ foo: json["foo"],
40+ );
41+
42+ Map<String, dynamic> toJson() => {
43+ "foo": foo,
44+ };
45+}
Aschema-elixirdefault / QuickType.ex+75 −0
@@ -0,0 +1,75 @@
1+# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
2+#
3+# Add Jason to your mix.exs
4+#
5+# Decode a JSON string: TopLevel.from_json(data)
6+# Encode into a JSON string: TopLevel.to_json(struct)
7+
8+defmodule CodingKeys do
9+ @enforce_keys [:foo]
10+ defstruct [:foo]
11+
12+ @type t :: %__MODULE__{
13+ foo: String.t()
14+ }
15+
16+ def from_map(m) do
17+ %CodingKeys{
18+ foo: m["foo"],
19+ }
20+ end
21+
22+ def from_json(json) do
23+ json
24+ |> Jason.decode!()
25+ |> from_map()
26+ end
27+
28+ def to_map(struct) do
29+ %{
30+ "foo" => struct.foo,
31+ }
32+ end
33+
34+ def to_json(struct) do
35+ struct
36+ |> to_map()
37+ |> Jason.encode!()
38+ end
39+end
40+
41+defmodule TopLevel do
42+ @enforce_keys [:coding_keys, :name]
43+ defstruct [:coding_keys, :name]
44+
45+ @type t :: %__MODULE__{
46+ coding_keys: CodingKeys.t(),
47+ name: String.t()
48+ }
49+
50+ def from_map(m) do
51+ %TopLevel{
52+ coding_keys: CodingKeys.from_map(m["coding-keys"]),
53+ name: m["name"],
54+ }
55+ end
56+
57+ def from_json(json) do
58+ json
59+ |> Jason.decode!()
60+ |> from_map()
61+ end
62+
63+ def to_map(struct) do
64+ %{
65+ "coding-keys" => CodingKeys.to_map(struct.coding_keys),
66+ "name" => struct.name,
67+ }
68+ end
69+
70+ def to_json(struct) do
71+ struct
72+ |> to_map()
73+ |> Jason.encode!()
74+ end
75+end
Aschema-elmdefault / QuickType.elm+70 −0
@@ -0,0 +1,70 @@
1+-- To decode the JSON data, add this file to your project, run
2+--
3+-- elm install NoRedInk/elm-json-decode-pipeline
4+--
5+-- add these imports
6+--
7+-- import Json.Decode exposing (decodeString)
8+-- import QuickType exposing (quickType)
9+--
10+-- and you're off to the races with
11+--
12+-- decodeString quickType myJsonString
13+
14+module QuickType exposing
15+ ( QuickType
16+ , quickTypeToString
17+ , quickType
18+ , CodingKeys
19+ )
20+
21+import Json.Decode as Jdec
22+import Json.Decode.Pipeline as Jpipe
23+import Json.Encode as Jenc
24+import Dict exposing (Dict)
25+
26+type alias QuickType =
27+ { codingKeys : CodingKeys
28+ , name : String
29+ }
30+
31+type alias CodingKeys =
32+ { foo : String
33+ }
34+
35+-- decoders and encoders
36+
37+quickTypeToString : QuickType -> String
38+quickTypeToString r = Jenc.encode 0 (encodeQuickType r)
39+
40+quickType : Jdec.Decoder QuickType
41+quickType =
42+ Jdec.succeed QuickType
43+ |> Jpipe.required "coding-keys" codingKeys
44+ |> Jpipe.required "name" Jdec.string
45+
46+encodeQuickType : QuickType -> Jenc.Value
47+encodeQuickType x =
48+ Jenc.object
49+ [ ("coding-keys", encodeCodingKeys x.codingKeys)
50+ , ("name", Jenc.string x.name)
51+ ]
52+
53+codingKeys : Jdec.Decoder CodingKeys
54+codingKeys =
55+ Jdec.succeed CodingKeys
56+ |> Jpipe.required "foo" Jdec.string
57+
58+encodeCodingKeys : CodingKeys -> Jenc.Value
59+encodeCodingKeys x =
60+ Jenc.object
61+ [ ("foo", Jenc.string x.foo)
62+ ]
63+
64+--- encoder helpers
65+
66+makeNullableEncoder : (a -> Jenc.Value) -> Maybe a -> Jenc.Value
67+makeNullableEncoder f m =
68+ case m of
69+ Just x -> f x
70+ Nothing -> Jenc.null
Aschema-flowdefault / TopLevel.js+199 −0
@@ -0,0 +1,199 @@
1+// @flow
2+
3+// To parse this data:
4+//
5+// const Convert = require("./TopLevel");
6+//
7+// const topLevel = Convert.toTopLevel(json);
8+//
9+// These functions will throw an error if the JSON doesn't
10+// match the expected interface, even if the JSON is valid.
11+
12+export type TopLevel = {
13+ "coding-keys": CodingKeys;
14+ name: string;
15+ [property: string]: mixed;
16+};
17+
18+export type CodingKeys = {
19+ foo: string;
20+ [property: string]: mixed;
21+};
22+
23+// Converts JSON strings to/from your types
24+// and asserts the results of JSON.parse at runtime
25+function toTopLevel(json: string): TopLevel {
26+ return cast(JSON.parse(json), r("TopLevel"));
27+}
28+
29+function topLevelToJson(value: TopLevel): string {
30+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
31+}
32+
33+function invalidValue(typ: any, val: any, key: any, parent: any = '') {
34+ const prettyTyp = prettyTypeName(typ);
35+ const parentText = parent ? ` on ${parent}` : '';
36+ const keyText = key ? ` for key "${key}"` : '';
37+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
38+}
39+
40+function prettyTypeName(typ: any): string {
41+ if (Array.isArray(typ)) {
42+ if (typ.length === 2 && typ[0] === undefined) {
43+ return `an optional ${prettyTypeName(typ[1])}`;
44+ } else {
45+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
46+ }
47+ } else if (typeof typ === "object" && typ.literal !== undefined) {
48+ return typ.literal;
49+ } else {
50+ return typeof typ;
51+ }
52+}
53+
54+function jsonToJSProps(typ: any): any {
55+ if (typ.jsonToJS === undefined) {
56+ const map: any = {};
57+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
58+ typ.jsonToJS = map;
59+ }
60+ return typ.jsonToJS;
61+}
62+
63+function jsToJSONProps(typ: any): any {
64+ if (typ.jsToJSON === undefined) {
65+ const map: any = {};
66+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
67+ typ.jsToJSON = map;
68+ }
69+ return typ.jsToJSON;
70+}
71+
72+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
73+ function transformPrimitive(typ: string, val: any): any {
74+ if (typeof typ === typeof val) return val;
75+ return invalidValue(typ, val, key, parent);
76+ }
77+
78+ function transformUnion(typs: any[], val: any): any {
79+ // val must validate against one typ in typs
80+ const l = typs.length;
81+ for (let i = 0; i < l; i++) {
82+ const typ = typs[i];
83+ try {
84+ return transform(val, typ, getProps);
85+ } catch (_) {}
86+ }
87+ return invalidValue(typs, val, key, parent);
88+ }
89+
90+ function transformEnum(cases: string[], val: any): any {
91+ if (cases.indexOf(val) !== -1) return val;
92+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
93+ }
94+
95+ function transformArray(typ: any, val: any): any {
96+ // val must be an array with no invalid elements
97+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
98+ return val.map(el => transform(el, typ, getProps));
99+ }
100+
101+ function transformDate(val: any): any {
102+ if (val === null) {
103+ return null;
104+ }
105+ const d = new Date(val);
106+ if (isNaN(d.valueOf())) {
107+ return invalidValue(l("Date"), val, key, parent);
108+ }
109+ return d;
110+ }
111+
112+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
113+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
114+ return invalidValue(l(ref || "object"), val, key, parent);
115+ }
116+ const result: any = {};
117+ Object.getOwnPropertyNames(props).forEach(key => {
118+ const prop = props[key];
119+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
120+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
121+ });
122+ Object.getOwnPropertyNames(val).forEach(key => {
123+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
124+ result[key] = transform(val[key], additional, getProps, key, ref);
125+ }
126+ });
127+ return result;
128+ }
129+
130+ if (typ === "any") return val;
131+ if (typ === null) {
132+ if (val === null) return val;
133+ return invalidValue(typ, val, key, parent);
134+ }
135+ if (typ === false) return invalidValue(typ, val, key, parent);
136+ let ref: any = undefined;
137+ while (typeof typ === "object" && typ.ref !== undefined) {
138+ ref = typ.ref;
139+ typ = typeMap[typ.ref];
140+ }
141+ if (Array.isArray(typ)) return transformEnum(typ, val);
142+ if (typeof typ === "object") {
143+ return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
144+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
145+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
146+ : invalidValue(typ, val, key, parent);
147+ }
148+ // Numbers can be parsed by Date but shouldn't be.
149+ if (typ === Date && typeof val !== "number") return transformDate(val);
150+ return transformPrimitive(typ, val);
151+}
152+
153+function cast<T>(val: any, typ: any): T {
154+ return transform(val, typ, jsonToJSProps);
155+}
156+
157+function uncast<T>(val: T, typ: any): any {
158+ return transform(val, typ, jsToJSONProps);
159+}
160+
161+function l(typ: any) {
162+ return { literal: typ };
163+}
164+
165+function a(typ: any) {
166+ return { arrayItems: typ };
167+}
168+
169+function u(...typs: any[]) {
170+ return { unionMembers: typs };
171+}
172+
173+function o(props: any[], additional: any) {
174+ return { props, additional };
175+}
176+
177+function m(additional: any) {
178+ const props: any[] = [];
179+ return { props, additional };
180+}
181+
182+function r(name: string) {
183+ return { ref: name };
184+}
185+
186+const typeMap: any = {
187+ "TopLevel": o([
188+ { json: "coding-keys", js: "coding-keys", typ: r("CodingKeys") },
189+ { json: "name", js: "name", typ: "" },
190+ ], "any"),
191+ "CodingKeys": o([
192+ { json: "foo", js: "foo", typ: "" },
193+ ], "any"),
194+};
195+
196+module.exports = {
197+ "topLevelToJson": topLevelToJson,
198+ "toTopLevel": toTopLevel,
199+};
Aschema-golangdefault / quicktype.go+28 −0
@@ -0,0 +1,28 @@
1+// Code generated from JSON Schema using quicktype. DO NOT EDIT.
2+// To parse and unparse this JSON data, add this code to your project and do:
3+//
4+// topLevel, err := UnmarshalTopLevel(bytes)
5+// bytes, err = topLevel.Marshal()
6+
7+package main
8+
9+import "encoding/json"
10+
11+func UnmarshalTopLevel(data []byte) (TopLevel, error) {
12+ var r TopLevel
13+ err := json.Unmarshal(data, &r)
14+ return r, err
15+}
16+
17+func (r *TopLevel) Marshal() ([]byte, error) {
18+ return json.Marshal(r)
19+}
20+
21+type TopLevel struct {
22+ CodingKeys CodingKeys `json:"coding-keys"`
23+ Name string `json:"name"`
24+}
25+
26+type CodingKeys struct {
27+ Foo string `json:"foo"`
28+}
Aschema-haskelldefault / QuickType.hs+48 −0
@@ -0,0 +1,48 @@
1+{-# LANGUAGE StrictData #-}
2+{-# LANGUAGE OverloadedStrings #-}
3+
4+module QuickType
5+ ( QuickType (..)
6+ , CodingKeys (..)
7+ , decodeTopLevel
8+ ) where
9+
10+import Data.Aeson
11+import Data.Aeson.Types (emptyObject)
12+import Data.ByteString.Lazy (ByteString)
13+import Data.HashMap.Strict (HashMap)
14+import Data.Text (Text)
15+
16+data QuickType = QuickType
17+ { codingKeysQuickType :: CodingKeys
18+ , nameQuickType :: Text
19+ } deriving (Show)
20+
21+data CodingKeys = CodingKeys
22+ { fooCodingKeys :: Text
23+ } deriving (Show)
24+
25+decodeTopLevel :: ByteString -> Maybe QuickType
26+decodeTopLevel = decode
27+
28+instance ToJSON QuickType where
29+ toJSON (QuickType codingKeysQuickType nameQuickType) =
30+ object
31+ [ "coding-keys" .= codingKeysQuickType
32+ , "name" .= nameQuickType
33+ ]
34+
35+instance FromJSON QuickType where
36+ parseJSON (Object v) = QuickType
37+ <$> v .: "coding-keys"
38+ <*> v .: "name"
39+
40+instance ToJSON CodingKeys where
41+ toJSON (CodingKeys fooCodingKeys) =
42+ object
43+ [ "foo" .= fooCodingKeys
44+ ]
45+
46+instance FromJSON CodingKeys where
47+ parseJSON (Object v) = CodingKeys
48+ <$> v .: "foo"
Aschema-java-datetime-legacydefault / src / main / java / io / quicktype / CodingKeys.java+12 −0
@@ -0,0 +1,12 @@
1+package io.quicktype;
2+
3+import com.fasterxml.jackson.annotation.*;
4+
5+public class CodingKeys {
6+ private String foo;
7+
8+ @JsonProperty("foo")
9+ public String getFoo() { return foo; }
10+ @JsonProperty("foo")
11+ public void setFoo(String value) { this.foo = value; }
12+}
Aschema-java-datetime-legacydefault / src / main / java / io / quicktype / Converter.java+121 −0
@@ -0,0 +1,121 @@
1+// To use this code, add the following Maven dependency to your project:
2+//
3+//
4+// com.fasterxml.jackson.core : jackson-databind : 2.9.0
5+//
6+//
7+// Import this package:
8+//
9+// import io.quicktype.Converter;
10+//
11+// Then you can deserialize a JSON string with
12+//
13+// TopLevel data = Converter.fromJsonString(jsonString);
14+
15+package io.quicktype;
16+
17+import java.io.IOException;
18+import com.fasterxml.jackson.databind.*;
19+import com.fasterxml.jackson.databind.module.SimpleModule;
20+import com.fasterxml.jackson.core.JsonParser;
21+import com.fasterxml.jackson.core.JsonProcessingException;
22+import java.util.*;
23+import java.util.Date;
24+import java.text.SimpleDateFormat;
25+
26+public class Converter {
27+ // Date-time helpers
28+
29+ private static final String[] DATE_TIME_FORMATS = {
30+ "yyyy-MM-dd'T'HH:mm:ss.SX",
31+ "yyyy-MM-dd'T'HH:mm:ss.S",
32+ "yyyy-MM-dd'T'HH:mm:ssX",
33+ "yyyy-MM-dd'T'HH:mm:ss",
34+ "yyyy-MM-dd HH:mm:ss.SX",
35+ "yyyy-MM-dd HH:mm:ss.S",
36+ "yyyy-MM-dd HH:mm:ssX",
37+ "yyyy-MM-dd HH:mm:ss",
38+ "HH:mm:ss.SZ",
39+ "HH:mm:ss.S",
40+ "HH:mm:ssZ",
41+ "HH:mm:ss",
42+ "yyyy-MM-dd",
43+ };
44+
45+ public static Date parseAllDateTimeString(String str) {
46+ for (String format : DATE_TIME_FORMATS) {
47+ try {
48+ return new SimpleDateFormat(format).parse(str);
49+ } catch (Exception ex) {
50+ // Ignored
51+ }
52+ }
53+ return null;
54+ }
55+
56+ public static String serializeDateTime(Date datetime) {
57+ return new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ").format(datetime);
58+ }
59+
60+ public static String serializeDate(Date datetime) {
61+ return new SimpleDateFormat("yyyy-MM-dd").format(datetime);
62+ }
63+
64+ public static String serializeTime(Date datetime) {
65+ return new SimpleDateFormat("hh:mm:ssZ").format(datetime);
66+ }
67+ // Serialize/deserialize helpers
68+
69+ public static TopLevel fromJsonString(String json) throws IOException {
70+ return getObjectReader().readValue(json);
71+ }
72+
73+ public static String toJsonString(TopLevel obj) throws JsonProcessingException {
74+ return getObjectWriter().writeValueAsString(obj);
75+ }
76+
77+ private static ObjectReader reader;
78+ private static ObjectWriter writer;
79+
80+ private static void instantiateMapper() {
81+ ObjectMapper mapper = new ObjectMapper();
82+ mapper.findAndRegisterModules();
83+ mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
84+ mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
85+ SimpleModule module = new SimpleModule();
86+ module.addDeserializer(Date.class, new JsonDeserializer<Date>() {
87+ @Override
88+ public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
89+ String value = jsonParser.getText();
90+ return Converter.parseAllDateTimeString(value);
91+ }
92+ });
93+ module.addDeserializer(Date.class, new JsonDeserializer<Date>() {
94+ @Override
95+ public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
96+ String value = jsonParser.getText();
97+ return Converter.parseAllDateTimeString(value);
98+ }
99+ });
100+ module.addDeserializer(Date.class, new JsonDeserializer<Date>() {
101+ @Override
102+ public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
103+ String value = jsonParser.getText();
104+ return Converter.parseAllDateTimeString(value);
105+ }
106+ });
107+ mapper.registerModule(module);
108+ reader = mapper.readerFor(TopLevel.class);
109+ writer = mapper.writerFor(TopLevel.class);
110+ }
111+
112+ private static ObjectReader getObjectReader() {
113+ if (reader == null) instantiateMapper();
114+ return reader;
115+ }
116+
117+ private static ObjectWriter getObjectWriter() {
118+ if (writer == null) instantiateMapper();
119+ return writer;
120+ }
121+}
Aschema-java-datetime-legacydefault / src / main / java / io / quicktype / TopLevel.java+18 −0
@@ -0,0 +1,18 @@
1+package io.quicktype;
2+
3+import com.fasterxml.jackson.annotation.*;
4+
5+public class TopLevel {
6+ private CodingKeys codingKeys;
7+ private String name;
8+
9+ @JsonProperty("coding-keys")
10+ public CodingKeys getCodingKeys() { return codingKeys; }
11+ @JsonProperty("coding-keys")
12+ public void setCodingKeys(CodingKeys value) { this.codingKeys = value; }
13+
14+ @JsonProperty("name")
15+ public String getName() { return name; }
16+ @JsonProperty("name")
17+ public void setName(String value) { this.name = value; }
18+}
Aschema-java-lombokdefault / src / main / java / io / quicktype / CodingKeys.java+12 −0
@@ -0,0 +1,12 @@
1+package io.quicktype;
2+
3+import com.fasterxml.jackson.annotation.*;
4+
5+public class CodingKeys {
6+ private String foo;
7+
8+ @JsonProperty("foo")
9+ public String getFoo() { return foo; }
10+ @JsonProperty("foo")
11+ public void setFoo(String value) { this.foo = value; }
12+}
Aschema-java-lombokdefault / src / main / java / io / quicktype / Converter.java+101 −0
@@ -0,0 +1,101 @@
1+// To use this code, add the following Maven dependency to your project:
2+//
3+//
4+// com.fasterxml.jackson.core : jackson-databind : 2.9.0
5+// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0
6+//
7+// Import this package:
8+//
9+// import io.quicktype.Converter;
10+//
11+// Then you can deserialize a JSON string with
12+//
13+// TopLevel data = Converter.fromJsonString(jsonString);
14+
15+package io.quicktype;
16+
17+import java.io.IOException;
18+import com.fasterxml.jackson.databind.*;
19+import com.fasterxml.jackson.databind.module.SimpleModule;
20+import com.fasterxml.jackson.core.JsonParser;
21+import com.fasterxml.jackson.core.JsonProcessingException;
22+import java.util.*;
23+import java.time.LocalDate;
24+import java.time.OffsetDateTime;
25+import java.time.OffsetTime;
26+import java.time.ZoneOffset;
27+import java.time.ZonedDateTime;
28+import java.time.format.DateTimeFormatter;
29+import java.time.format.DateTimeFormatterBuilder;
30+import java.time.temporal.ChronoField;
31+
32+public class Converter {
33+ // Date-time helpers
34+
35+ private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder()
36+ .appendOptional(DateTimeFormatter.ISO_DATE_TIME)
37+ .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME)
38+ .appendOptional(DateTimeFormatter.ISO_INSTANT)
39+ .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX"))
40+ .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX"))
41+ .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
42+ .toFormatter()
43+ .withZone(ZoneOffset.UTC);
44+
45+ public static OffsetDateTime parseDateTimeString(String str) {
46+ return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime();
47+ }
48+
49+ private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder()
50+ .appendOptional(DateTimeFormatter.ISO_TIME)
51+ .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME)
52+ .parseDefaulting(ChronoField.YEAR, 2020)
53+ .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1)
54+ .parseDefaulting(ChronoField.DAY_OF_MONTH, 1)
55+ .toFormatter()
56+ .withZone(ZoneOffset.UTC);
57+
58+ public static OffsetTime parseTimeString(String str) {
59+ return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime();
60+ }
61+ // Serialize/deserialize helpers
62+
63+ public static TopLevel fromJsonString(String json) throws IOException {
64+ return getObjectReader().readValue(json);
65+ }
66+
67+ public static String toJsonString(TopLevel obj) throws JsonProcessingException {
68+ return getObjectWriter().writeValueAsString(obj);
69+ }
70+
71+ private static ObjectReader reader;
72+ private static ObjectWriter writer;
73+
74+ private static void instantiateMapper() {
75+ ObjectMapper mapper = new ObjectMapper();
76+ mapper.findAndRegisterModules();
77+ mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
78+ mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
79+ SimpleModule module = new SimpleModule();
80+ module.addDeserializer(OffsetDateTime.class, new JsonDeserializer<OffsetDateTime>() {
81+ @Override
82+ public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
83+ String value = jsonParser.getText();
84+ return Converter.parseDateTimeString(value);
85+ }
86+ });
87+ mapper.registerModule(module);
88+ reader = mapper.readerFor(TopLevel.class);
89+ writer = mapper.writerFor(TopLevel.class);
90+ }
91+
92+ private static ObjectReader getObjectReader() {
93+ if (reader == null) instantiateMapper();
94+ return reader;
95+ }
96+
97+ private static ObjectWriter getObjectWriter() {
98+ if (writer == null) instantiateMapper();
99+ return writer;
100+ }
101+}
Aschema-java-lombokdefault / src / main / java / io / quicktype / TopLevel.java+18 −0
@@ -0,0 +1,18 @@
1+package io.quicktype;
2+
3+import com.fasterxml.jackson.annotation.*;
4+
5+public class TopLevel {
6+ private CodingKeys codingKeys;
7+ private String name;
8+
9+ @JsonProperty("coding-keys")
10+ public CodingKeys getCodingKeys() { return codingKeys; }
11+ @JsonProperty("coding-keys")
12+ public void setCodingKeys(CodingKeys value) { this.codingKeys = value; }
13+
14+ @JsonProperty("name")
15+ public String getName() { return name; }
16+ @JsonProperty("name")
17+ public void setName(String value) { this.name = value; }
18+}
Aschema-javadefault / src / main / java / io / quicktype / CodingKeys.java+12 −0
@@ -0,0 +1,12 @@
1+package io.quicktype;
2+
3+import com.fasterxml.jackson.annotation.*;
4+
5+public class CodingKeys {
6+ private String foo;
7+
8+ @JsonProperty("foo")
9+ public String getFoo() { return foo; }
10+ @JsonProperty("foo")
11+ public void setFoo(String value) { this.foo = value; }
12+}
Aschema-javadefault / src / main / java / io / quicktype / Converter.java+101 −0
@@ -0,0 +1,101 @@
1+// To use this code, add the following Maven dependency to your project:
2+//
3+//
4+// com.fasterxml.jackson.core : jackson-databind : 2.9.0
5+// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0
6+//
7+// Import this package:
8+//
9+// import io.quicktype.Converter;
10+//
11+// Then you can deserialize a JSON string with
12+//
13+// TopLevel data = Converter.fromJsonString(jsonString);
14+
15+package io.quicktype;
16+
17+import java.io.IOException;
18+import com.fasterxml.jackson.databind.*;
19+import com.fasterxml.jackson.databind.module.SimpleModule;
20+import com.fasterxml.jackson.core.JsonParser;
21+import com.fasterxml.jackson.core.JsonProcessingException;
22+import java.util.*;
23+import java.time.LocalDate;
24+import java.time.OffsetDateTime;
25+import java.time.OffsetTime;
26+import java.time.ZoneOffset;
27+import java.time.ZonedDateTime;
28+import java.time.format.DateTimeFormatter;
29+import java.time.format.DateTimeFormatterBuilder;
30+import java.time.temporal.ChronoField;
31+
32+public class Converter {
33+ // Date-time helpers
34+
35+ private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder()
36+ .appendOptional(DateTimeFormatter.ISO_DATE_TIME)
37+ .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME)
38+ .appendOptional(DateTimeFormatter.ISO_INSTANT)
39+ .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX"))
40+ .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX"))
41+ .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
42+ .toFormatter()
43+ .withZone(ZoneOffset.UTC);
44+
45+ public static OffsetDateTime parseDateTimeString(String str) {
46+ return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime();
47+ }
48+
49+ private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder()
50+ .appendOptional(DateTimeFormatter.ISO_TIME)
51+ .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME)
52+ .parseDefaulting(ChronoField.YEAR, 2020)
53+ .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1)
54+ .parseDefaulting(ChronoField.DAY_OF_MONTH, 1)
55+ .toFormatter()
56+ .withZone(ZoneOffset.UTC);
57+
58+ public static OffsetTime parseTimeString(String str) {
59+ return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime();
60+ }
61+ // Serialize/deserialize helpers
62+
63+ public static TopLevel fromJsonString(String json) throws IOException {
64+ return getObjectReader().readValue(json);
65+ }
66+
67+ public static String toJsonString(TopLevel obj) throws JsonProcessingException {
68+ return getObjectWriter().writeValueAsString(obj);
69+ }
70+
71+ private static ObjectReader reader;
72+ private static ObjectWriter writer;
73+
74+ private static void instantiateMapper() {
75+ ObjectMapper mapper = new ObjectMapper();
76+ mapper.findAndRegisterModules();
77+ mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
78+ mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
79+ SimpleModule module = new SimpleModule();
80+ module.addDeserializer(OffsetDateTime.class, new JsonDeserializer<OffsetDateTime>() {
81+ @Override
82+ public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
83+ String value = jsonParser.getText();
84+ return Converter.parseDateTimeString(value);
85+ }
86+ });
87+ mapper.registerModule(module);
88+ reader = mapper.readerFor(TopLevel.class);
89+ writer = mapper.writerFor(TopLevel.class);
90+ }
91+
92+ private static ObjectReader getObjectReader() {
93+ if (reader == null) instantiateMapper();
94+ return reader;
95+ }
96+
97+ private static ObjectWriter getObjectWriter() {
98+ if (writer == null) instantiateMapper();
99+ return writer;
100+ }
101+}
Aschema-javadefault / src / main / java / io / quicktype / TopLevel.java+18 −0
@@ -0,0 +1,18 @@
1+package io.quicktype;
2+
3+import com.fasterxml.jackson.annotation.*;
4+
5+public class TopLevel {
6+ private CodingKeys codingKeys;
7+ private String name;
8+
9+ @JsonProperty("coding-keys")
10+ public CodingKeys getCodingKeys() { return codingKeys; }
11+ @JsonProperty("coding-keys")
12+ public void setCodingKeys(CodingKeys value) { this.codingKeys = value; }
13+
14+ @JsonProperty("name")
15+ public String getName() { return name; }
16+ @JsonProperty("name")
17+ public void setName(String value) { this.name = value; }
18+}
Aschema-javascriptdefault / TopLevel.js+186 −0
@@ -0,0 +1,186 @@
1+// To parse this data:
2+//
3+// const Convert = require("./TopLevel");
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+// Converts JSON strings to/from your types
11+// and asserts the results of JSON.parse at runtime
12+function toTopLevel(json) {
13+ return cast(JSON.parse(json), r("TopLevel"));
14+}
15+
16+function topLevelToJson(value) {
17+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
18+}
19+
20+function invalidValue(typ, val, key, parent = '') {
21+ const prettyTyp = prettyTypeName(typ);
22+ const parentText = parent ? ` on ${parent}` : '';
23+ const keyText = key ? ` for key "${key}"` : '';
24+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
25+}
26+
27+function prettyTypeName(typ) {
28+ if (Array.isArray(typ)) {
29+ if (typ.length === 2 && typ[0] === undefined) {
30+ return `an optional ${prettyTypeName(typ[1])}`;
31+ } else {
32+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
33+ }
34+ } else if (typeof typ === "object" && typ.literal !== undefined) {
35+ return typ.literal;
36+ } else {
37+ return typeof typ;
38+ }
39+}
40+
41+function jsonToJSProps(typ) {
42+ if (typ.jsonToJS === undefined) {
43+ const map = {};
44+ typ.props.forEach((p) => map[p.json] = { key: p.js, typ: p.typ });
45+ typ.jsonToJS = map;
46+ }
47+ return typ.jsonToJS;
48+}
49+
50+function jsToJSONProps(typ) {
51+ if (typ.jsToJSON === undefined) {
52+ const map = {};
53+ typ.props.forEach((p) => map[p.js] = { key: p.json, typ: p.typ });
54+ typ.jsToJSON = map;
55+ }
56+ return typ.jsToJSON;
57+}
58+
59+function transform(val, typ, getProps, key = '', parent = '') {
60+ function transformPrimitive(typ, val) {
61+ if (typeof typ === typeof val) return val;
62+ return invalidValue(typ, val, key, parent);
63+ }
64+
65+ function transformUnion(typs, val) {
66+ // val must validate against one typ in typs
67+ const l = typs.length;
68+ for (let i = 0; i < l; i++) {
69+ const typ = typs[i];
70+ try {
71+ return transform(val, typ, getProps);
72+ } catch (_) {}
73+ }
74+ return invalidValue(typs, val, key, parent);
75+ }
76+
77+ function transformEnum(cases, val) {
78+ if (cases.indexOf(val) !== -1) return val;
79+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
80+ }
81+
82+ function transformArray(typ, val) {
83+ // val must be an array with no invalid elements
84+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
85+ return val.map(el => transform(el, typ, getProps));
86+ }
87+
88+ function transformDate(val) {
89+ if (val === null) {
90+ return null;
91+ }
92+ const d = new Date(val);
93+ if (isNaN(d.valueOf())) {
94+ return invalidValue(l("Date"), val, key, parent);
95+ }
96+ return d;
97+ }
98+
99+ function transformObject(props, additional, val) {
100+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
101+ return invalidValue(l(ref || "object"), val, key, parent);
102+ }
103+ const result = {};
104+ Object.getOwnPropertyNames(props).forEach(key => {
105+ const prop = props[key];
106+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
107+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
108+ });
109+ Object.getOwnPropertyNames(val).forEach(key => {
110+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
111+ result[key] = transform(val[key], additional, getProps, key, ref);
112+ }
113+ });
114+ return result;
115+ }
116+
117+ if (typ === "any") return val;
118+ if (typ === null) {
119+ if (val === null) return val;
120+ return invalidValue(typ, val, key, parent);
121+ }
122+ if (typ === false) return invalidValue(typ, val, key, parent);
123+ let ref = undefined;
124+ while (typeof typ === "object" && typ.ref !== undefined) {
125+ ref = typ.ref;
126+ typ = typeMap[typ.ref];
127+ }
128+ if (Array.isArray(typ)) return transformEnum(typ, val);
129+ if (typeof typ === "object") {
130+ return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
131+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
132+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
133+ : invalidValue(typ, val, key, parent);
134+ }
135+ // Numbers can be parsed by Date but shouldn't be.
136+ if (typ === Date && typeof val !== "number") return transformDate(val);
137+ return transformPrimitive(typ, val);
138+}
139+
140+function cast(val, typ) {
141+ return transform(val, typ, jsonToJSProps);
142+}
143+
144+function uncast(val, typ) {
145+ return transform(val, typ, jsToJSONProps);
146+}
147+
148+function l(typ) {
149+ return { literal: typ };
150+}
151+
152+function a(typ) {
153+ return { arrayItems: typ };
154+}
155+
156+function u(...typs) {
157+ return { unionMembers: typs };
158+}
159+
160+function o(props, additional) {
161+ return { props, additional };
162+}
163+
164+function m(additional) {
165+ const props = [];
166+ return { props, additional };
167+}
168+
169+function r(name) {
170+ return { ref: name };
171+}
172+
173+const typeMap = {
174+ "TopLevel": o([
175+ { json: "coding-keys", js: "coding-keys", typ: r("CodingKeys") },
176+ { json: "name", js: "name", typ: "" },
177+ ], "any"),
178+ "CodingKeys": o([
179+ { json: "foo", js: "foo", typ: "" },
180+ ], "any"),
181+};
182+
183+module.exports = {
184+ "topLevelToJson": topLevelToJson,
185+ "toTopLevel": toTopLevel,
186+};
Aschema-kotlin-jacksondefault / TopLevel.kt+38 −0
@@ -0,0 +1,38 @@
1+// To parse the JSON, install jackson-module-kotlin and do:
2+//
3+// val topLevel = TopLevel.fromJson(jsonString)
4+
5+package quicktype
6+
7+import com.fasterxml.jackson.annotation.*
8+import com.fasterxml.jackson.core.*
9+import com.fasterxml.jackson.databind.*
10+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
11+import com.fasterxml.jackson.databind.module.SimpleModule
12+import com.fasterxml.jackson.databind.node.*
13+import com.fasterxml.jackson.databind.ser.std.StdSerializer
14+import com.fasterxml.jackson.module.kotlin.*
15+
16+val mapper = jacksonObjectMapper().apply {
17+ propertyNamingStrategy = PropertyNamingStrategy.LOWER_CAMEL_CASE
18+ setSerializationInclusion(JsonInclude.Include.NON_NULL)
19+}
20+
21+data class TopLevel (
22+ @get:JsonProperty("coding-keys", required=true)@field:JsonProperty("coding-keys", required=true)
23+ val codingKeys: CodingKeys,
24+
25+ @get:JsonProperty(required=true)@field:JsonProperty(required=true)
26+ val name: String
27+) {
28+ fun toJson() = mapper.writeValueAsString(this)
29+
30+ companion object {
31+ fun fromJson(json: String) = mapper.readValue<TopLevel>(json)
32+ }
33+}
34+
35+data class CodingKeys (
36+ @get:JsonProperty(required=true)@field:JsonProperty(required=true)
37+ val foo: String
38+)
Aschema-kotlindefault / TopLevel.kt+26 −0
@@ -0,0 +1,26 @@
1+// To parse the JSON, install Klaxon and do:
2+//
3+// val topLevel = TopLevel.fromJson(jsonString)
4+
5+package quicktype
6+
7+import com.beust.klaxon.*
8+
9+private val klaxon = Klaxon()
10+
11+data class TopLevel (
12+ @Json(name = "coding-keys")
13+ val codingKeys: CodingKeys,
14+
15+ val name: String
16+) {
17+ public fun toJson() = klaxon.toJsonString(this)
18+
19+ companion object {
20+ public fun fromJson(json: String) = klaxon.parse<TopLevel>(json)
21+ }
22+}
23+
24+data class CodingKeys (
25+ val foo: String
26+)
Aschema-kotlinxdefault / TopLevel.kt+24 −0
@@ -0,0 +1,24 @@
1+// To parse the JSON, install kotlin's serialization plugin and do:
2+//
3+// val json = Json { allowStructuredMapKeys = true }
4+// val topLevel = json.parse(TopLevel.serializer(), jsonString)
5+
6+package quicktype
7+
8+import kotlinx.serialization.*
9+import kotlinx.serialization.json.*
10+import kotlinx.serialization.descriptors.*
11+import kotlinx.serialization.encoding.*
12+
13+@Serializable
14+data class TopLevel (
15+ @SerialName("coding-keys")
16+ val codingKeys: CodingKeys,
17+
18+ val name: String
19+)
20+
21+@Serializable
22+data class CodingKeys (
23+ val foo: String
24+)
Aschema-phpdefault / TopLevel.php+253 −0
@@ -0,0 +1,253 @@
1+<?php
2+declare(strict_types=1);
3+
4+// This is an autogenerated file:TopLevel
5+
6+class TopLevel {
7+ private CodingKeys $codingKeys; // json:coding-keys Required
8+ private string $name; // json:name Required
9+
10+ /**
11+ * @param CodingKeys $codingKeys
12+ * @param string $name
13+ */
14+ public function __construct(CodingKeys $codingKeys, string $name) {
15+ $this->codingKeys = $codingKeys;
16+ $this->name = $name;
17+ }
18+
19+ /**
20+ * @param stdClass $value
21+ * @throws Exception
22+ * @return CodingKeys
23+ */
24+ public static function fromCodingKeys(stdClass $value): CodingKeys {
25+ return CodingKeys::from($value); /*class*/
26+ }
27+
28+ /**
29+ * @throws Exception
30+ * @return stdClass
31+ */
32+ public function toCodingKeys(): stdClass {
33+ if (TopLevel::validateCodingKeys($this->codingKeys)) {
34+ return $this->codingKeys->to(); /*class*/
35+ }
36+ throw new Exception('never get to this TopLevel::codingKeys');
37+ }
38+
39+ /**
40+ * @param CodingKeys
41+ * @return bool
42+ * @throws Exception
43+ */
44+ public static function validateCodingKeys(CodingKeys $value): bool {
45+ $value->validate();
46+ return true;
47+ }
48+
49+ /**
50+ * @throws Exception
51+ * @return CodingKeys
52+ */
53+ public function getCodingKeys(): CodingKeys {
54+ if (TopLevel::validateCodingKeys($this->codingKeys)) {
55+ return $this->codingKeys;
56+ }
57+ throw new Exception('never get to getCodingKeys TopLevel::codingKeys');
58+ }
59+
60+ /**
61+ * @return CodingKeys
62+ */
63+ public static function sampleCodingKeys(): CodingKeys {
64+ return CodingKeys::sample(); /*31:codingKeys*/
65+ }
66+
67+ /**
68+ * @param string $value
69+ * @throws Exception
70+ * @return string
71+ */
72+ public static function fromName(string $value): string {
73+ return $value; /*string*/
74+ }
75+
76+ /**
77+ * @throws Exception
78+ * @return string
79+ */
80+ public function toName(): string {
81+ if (TopLevel::validateName($this->name)) {
82+ return $this->name; /*string*/
83+ }
84+ throw new Exception('never get to this TopLevel::name');
85+ }
86+
87+ /**
88+ * @param string
89+ * @return bool
90+ * @throws Exception
91+ */
92+ public static function validateName(string $value): bool {
93+ return true;
94+ }
95+
96+ /**
97+ * @throws Exception
98+ * @return string
99+ */
100+ public function getName(): string {
101+ if (TopLevel::validateName($this->name)) {
102+ return $this->name;
103+ }
104+ throw new Exception('never get to getName TopLevel::name');
105+ }
106+
107+ /**
108+ * @return string
109+ */
110+ public static function sampleName(): string {
111+ return 'TopLevel::name::32'; /*32:name*/
112+ }
113+
114+ /**
115+ * @throws Exception
116+ * @return bool
117+ */
118+ public function validate(): bool {
119+ return TopLevel::validateCodingKeys($this->codingKeys)
120+ || TopLevel::validateName($this->name);
121+ }
122+
123+ /**
124+ * @return stdClass
125+ * @throws Exception
126+ */
127+ public function to(): stdClass {
128+ $out = new stdClass();
129+ $out->{'coding-keys'} = $this->toCodingKeys();
130+ $out->{'name'} = $this->toName();
131+ return $out;
132+ }
133+
134+ /**
135+ * @param stdClass $obj
136+ * @return TopLevel
137+ * @throws Exception
138+ */
139+ public static function from(stdClass $obj): TopLevel {
140+ return new TopLevel(
141+ TopLevel::fromCodingKeys($obj->{'coding-keys'})
142+ ,TopLevel::fromName($obj->{'name'})
143+ );
144+ }
145+
146+ /**
147+ * @return TopLevel
148+ */
149+ public static function sample(): TopLevel {
150+ return new TopLevel(
151+ TopLevel::sampleCodingKeys()
152+ ,TopLevel::sampleName()
153+ );
154+ }
155+}
156+
157+// This is an autogenerated file:CodingKeys
158+
159+class CodingKeys {
160+ private string $foo; // json:foo Required
161+
162+ /**
163+ * @param string $foo
164+ */
165+ public function __construct(string $foo) {
166+ $this->foo = $foo;
167+ }
168+
169+ /**
170+ * @param string $value
171+ * @throws Exception
172+ * @return string
173+ */
174+ public static function fromFoo(string $value): string {
175+ return $value; /*string*/
176+ }
177+
178+ /**
179+ * @throws Exception
180+ * @return string
181+ */
182+ public function toFoo(): string {
183+ if (CodingKeys::validateFoo($this->foo)) {
184+ return $this->foo; /*string*/
185+ }
186+ throw new Exception('never get to this CodingKeys::foo');
187+ }
188+
189+ /**
190+ * @param string
191+ * @return bool
192+ * @throws Exception
193+ */
194+ public static function validateFoo(string $value): bool {
195+ return true;
196+ }
197+
198+ /**
199+ * @throws Exception
200+ * @return string
201+ */
202+ public function getFoo(): string {
203+ if (CodingKeys::validateFoo($this->foo)) {
204+ return $this->foo;
205+ }
206+ throw new Exception('never get to getFoo CodingKeys::foo');
207+ }
208+
209+ /**
210+ * @return string
211+ */
212+ public static function sampleFoo(): string {
213+ return 'CodingKeys::foo::31'; /*31:foo*/
214+ }
215+
216+ /**
217+ * @throws Exception
218+ * @return bool
219+ */
220+ public function validate(): bool {
221+ return CodingKeys::validateFoo($this->foo);
222+ }
223+
224+ /**
225+ * @return stdClass
226+ * @throws Exception
227+ */
228+ public function to(): stdClass {
229+ $out = new stdClass();
230+ $out->{'foo'} = $this->toFoo();
231+ return $out;
232+ }
233+
234+ /**
235+ * @param stdClass $obj
236+ * @return CodingKeys
237+ * @throws Exception
238+ */
239+ public static function from(stdClass $obj): CodingKeys {
240+ return new CodingKeys(
241+ CodingKeys::fromFoo($obj->{'foo'})
242+ );
243+ }
244+
245+ /**
246+ * @return CodingKeys
247+ */
248+ public static function sample(): CodingKeys {
249+ return new CodingKeys(
250+ CodingKeys::sampleFoo()
251+ );
252+ }
253+}
Aschema-pikedefault / TopLevel.pmod+56 −0
@@ -0,0 +1,56 @@
1+// This source has been automatically generated by quicktype.
2+// ( https://github.com/quicktype/quicktype )
3+//
4+// To use this code, simply import it into your project as a Pike module.
5+// To JSON-encode your object, you can pass it to `Standards.JSON.encode`
6+// or call `encode_json` on it.
7+//
8+// To decode a JSON string, first pass it to `Standards.JSON.decode`,
9+// and then pass the result to `<YourClass>_from_JSON`.
10+// It will return an instance of <YourClass>.
11+// Bear in mind that these functions have unexpected behavior,
12+// and will likely throw an error, if the JSON string does not
13+// match the expected interface, even if the JSON itself is valid.
14+
15+class TopLevel {
16+ CodingKeys coding_keys; // json: "coding-keys"
17+ string name; // json: "name"
18+
19+ string encode_json() {
20+ mapping(string:mixed) json = ([
21+ "coding-keys" : coding_keys,
22+ "name" : name,
23+ ]);
24+
25+ return Standards.JSON.encode(json);
26+ }
27+}
28+
29+TopLevel TopLevel_from_JSON(mixed json) {
30+ TopLevel retval = TopLevel();
31+
32+ retval.coding_keys = json["coding-keys"];
33+ retval.name = json["name"];
34+
35+ return retval;
36+}
37+
38+class CodingKeys {
39+ string foo; // json: "foo"
40+
41+ string encode_json() {
42+ mapping(string:mixed) json = ([
43+ "foo" : foo,
44+ ]);
45+
46+ return Standards.JSON.encode(json);
47+ }
48+}
49+
50+CodingKeys CodingKeys_from_JSON(mixed json) {
51+ CodingKeys retval = CodingKeys();
52+
53+ retval.foo = json["foo"];
54+
55+ return retval;
56+}
Aschema-pythondefault / quicktype.py+58 −0
@@ -0,0 +1,58 @@
1+from dataclasses import dataclass
2+from typing import Any, TypeVar, Type, cast
3+
4+
5+T = TypeVar("T")
6+
7+
8+def from_str(x: Any) -> str:
9+ assert isinstance(x, str)
10+ return x
11+
12+
13+def to_class(c: Type[T], x: Any) -> dict:
14+ assert isinstance(x, c)
15+ return cast(Any, x).to_dict()
16+
17+
18+@dataclass
19+class CodingKeys:
20+ foo: str
21+
22+ @staticmethod
23+ def from_dict(obj: Any) -> 'CodingKeys':
24+ assert isinstance(obj, dict)
25+ foo = from_str(obj.get("foo"))
26+ return CodingKeys(foo)
27+
28+ def to_dict(self) -> dict:
29+ result: dict = {}
30+ result["foo"] = from_str(self.foo)
31+ return result
32+
33+
34+@dataclass
35+class TopLevel:
36+ coding_keys: CodingKeys
37+ name: str
38+
39+ @staticmethod
40+ def from_dict(obj: Any) -> 'TopLevel':
41+ assert isinstance(obj, dict)
42+ coding_keys = CodingKeys.from_dict(obj.get("coding-keys"))
43+ name = from_str(obj.get("name"))
44+ return TopLevel(coding_keys, name)
45+
46+ def to_dict(self) -> dict:
47+ result: dict = {}
48+ result["coding-keys"] = to_class(CodingKeys, self.coding_keys)
49+ result["name"] = from_str(self.name)
50+ return result
51+
52+
53+def top_level_from_dict(s: Any) -> TopLevel:
54+ return TopLevel.from_dict(s)
55+
56+
57+def top_level_to_dict(x: TopLevel) -> Any:
58+ return to_class(TopLevel, x)
Aschema-rubydefault / TopLevel.rb+73 −0
@@ -0,0 +1,73 @@
1+# This code may look unusually verbose for Ruby (and it is), but
2+# it performs some subtle and complex validation of JSON data.
3+#
4+# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
5+#
6+# top_level = TopLevel.from_json! "{…}"
7+# puts top_level.coding_keys.foo
8+#
9+# If from_json! succeeds, the value returned matches the schema.
10+
11+require 'json'
12+require 'dry-types'
13+require 'dry-struct'
14+
15+module Types
16+ include Dry.Types(default: :nominal)
17+
18+ Hash = Strict::Hash
19+ String = Strict::String
20+end
21+
22+class CodingKeys < Dry::Struct
23+ attribute :foo, Types::String
24+
25+ def self.from_dynamic!(d)
26+ d = Types::Hash[d]
27+ new(
28+ foo: d.fetch("foo"),
29+ )
30+ end
31+
32+ def self.from_json!(json)
33+ from_dynamic!(JSON.parse(json))
34+ end
35+
36+ def to_dynamic
37+ {
38+ "foo" => foo,
39+ }
40+ end
41+
42+ def to_json(options = nil)
43+ JSON.generate(to_dynamic, options)
44+ end
45+end
46+
47+class TopLevel < Dry::Struct
48+ attribute :coding_keys, CodingKeys
49+ attribute :top_level_name, Types::String
50+
51+ def self.from_dynamic!(d)
52+ d = Types::Hash[d]
53+ new(
54+ coding_keys: CodingKeys.from_dynamic!(d.fetch("coding-keys")),
55+ top_level_name: d.fetch("name"),
56+ )
57+ end
58+
59+ def self.from_json!(json)
60+ from_dynamic!(JSON.parse(json))
61+ end
62+
63+ def to_dynamic
64+ {
65+ "coding-keys" => coding_keys.to_dynamic,
66+ "name" => top_level_name,
67+ }
68+ end
69+
70+ def to_json(options = nil)
71+ JSON.generate(to_dynamic, options)
72+ end
73+end
Aschema-rustdefault / module_under_test.rs+27 −0
@@ -0,0 +1,27 @@
1+// Example code that deserializes and serializes the model.
2+// extern crate serde;
3+// #[macro_use]
4+// extern crate serde_derive;
5+// extern crate serde_json;
6+//
7+// use generated_module::TopLevel;
8+//
9+// fn main() {
10+// let json = r#"{"answer": 42}"#;
11+// let model: TopLevel = serde_json::from_str(&json).unwrap();
12+// }
13+
14+use serde::{Serialize, Deserialize};
15+
16+#[derive(Debug, Clone, Serialize, Deserialize)]
17+#[serde(rename_all = "kebab-case")]
18+pub struct TopLevel {
19+ pub coding_keys: CodingKeys,
20+
21+ pub name: String,
22+}
23+
24+#[derive(Debug, Clone, Serialize, Deserialize)]
25+pub struct CodingKeys {
26+ pub foo: String,
27+}
Aschema-scala3-upickledefault / TopLevel.scala+75 −0
@@ -0,0 +1,75 @@
1+package quicktype
2+
3+// Custom pickler so that missing keys and JSON nulls both read as None,
4+// and None is left out when writing (upickle's default for Option is a
5+// JSON array).
6+object OptionPickler extends upickle.AttributeTagged:
7+ import upickle.default.Writer
8+ import upickle.default.Reader
9+ override implicit def OptionWriter[T: Writer]: Writer[Option[T]] =
10+ implicitly[Writer[T]].comap[Option[T]] {
11+ case None => null.asInstanceOf[T]
12+ case Some(x) => x
13+ }
14+
15+ override implicit def OptionReader[T: Reader]: Reader[Option[T]] = {
16+ new Reader.Delegate[Any, Option[T]](implicitly[Reader[T]].map(Some(_))){
17+ override def visitNull(index: Int) = None
18+ }
19+ }
20+end OptionPickler
21+
22+// If a union has a null in, then we'll need this too...
23+type NullValue = None.type
24+given OptionPickler.ReadWriter[NullValue] = OptionPickler.readwriter[ujson.Value].bimap[NullValue](
25+ _ => ujson.Null,
26+ json => if json.isNull then None else throw new upickle.core.Abort("not null")
27+)
28+
29+object JsonExt:
30+ val valueReader = OptionPickler.readwriter[ujson.Value]
31+
32+ // upickle's built-in primitive readers are lenient -- the numeric and
33+ // boolean readers accept strings, and the string reader accepts
34+ // numbers and booleans -- so untagged unions need strict readers to
35+ // pick the right member.
36+ val strictString: OptionPickler.Reader[String] = valueReader.map {
37+ case ujson.Str(s) => s
38+ case json => throw new upickle.core.Abort("expected string, got " + json)
39+ }
40+ val strictLong: OptionPickler.Reader[Long] = valueReader.map {
41+ case ujson.Num(n) if n.isWhole => n.toLong
42+ case json => throw new upickle.core.Abort("expected integer, got " + json)
43+ }
44+ val strictDouble: OptionPickler.Reader[Double] = valueReader.map {
45+ case ujson.Num(n) => n
46+ case json => throw new upickle.core.Abort("expected number, got " + json)
47+ }
48+ val strictBoolean: OptionPickler.Reader[Boolean] = valueReader.map {
49+ case ujson.Bool(b) => b
50+ case json => throw new upickle.core.Abort("expected boolean, got " + json)
51+ }
52+
53+ def badMerge[T](r1: => OptionPickler.Reader[?], rest: OptionPickler.Reader[?]*): OptionPickler.Reader[T] = valueReader.map { json =>
54+ var t: T | Null = null
55+ val stack = Vector.newBuilder[Throwable]
56+ (r1 +: rest).foreach { reader =>
57+ if t == null then
58+ try
59+ t = OptionPickler.read[T](json, trace = true)(using reader.asInstanceOf[OptionPickler.Reader[T]])
60+ catch
61+ case exc => stack += exc
62+ }
63+ if t != null then t.nn else throw new Exception(json.toString(), stack.result().headOption.getOrElse(null))
64+ }
65+end JsonExt
66+
67+
68+case class TopLevel (
69+ val `coding-keys` : CodingKeys,
70+ val name : String
71+) derives OptionPickler.ReadWriter
72+
73+case class CodingKeys (
74+ val foo : String
75+) derives OptionPickler.ReadWriter
Aschema-scala3default / TopLevel.scala+17 −0
@@ -0,0 +1,17 @@
1+package quicktype
2+
3+import io.circe.syntax._
4+import io.circe._
5+import cats.syntax.functor._
6+
7+// If a union has a null in, then we'll need this too...
8+type NullValue = None.type
9+
10+case class TopLevel (
11+ val `coding-keys` : CodingKeys,
12+ val name : String
13+) derives Encoder.AsObject, Decoder
14+
15+case class CodingKeys (
16+ val foo : String
17+) derives Encoder.AsObject, Decoder
Aschema-schemadefault / TopLevel.schema+36 −0
@@ -0,0 +1,36 @@
1+{
2+ "$schema": "http://json-schema.org/draft-06/schema#",
3+ "$ref": "#/definitions/TopLevel",
4+ "definitions": {
5+ "TopLevel": {
6+ "type": "object",
7+ "additionalProperties": {},
8+ "properties": {
9+ "coding-keys": {
10+ "$ref": "#/definitions/CodingKeys"
11+ },
12+ "name": {
13+ "type": "string"
14+ }
15+ },
16+ "required": [
17+ "coding-keys",
18+ "name"
19+ ],
20+ "title": "TopLevel"
21+ },
22+ "CodingKeys": {
23+ "type": "object",
24+ "additionalProperties": {},
25+ "properties": {
26+ "foo": {
27+ "type": "string"
28+ }
29+ },
30+ "required": [
31+ "foo"
32+ ],
33+ "title": "CodingKeys"
34+ }
35+ }
36+}
Aschema-swiftdefault / quicktype.swift+134 −0
@@ -0,0 +1,134 @@
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 codingKeys: CodingKeysClass
11+ let name: String
12+
13+ enum CodingKeys: String, CodingKey {
14+ case codingKeys = "coding-keys"
15+ case name = "name"
16+ }
17+}
18+
19+// MARK: TopLevel convenience initializers and mutators
20+
21+extension TopLevel {
22+ init(data: Data) throws {
23+ self = try newJSONDecoder().decode(TopLevel.self, from: data)
24+ }
25+
26+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
27+ guard let data = json.data(using: encoding) else {
28+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
29+ }
30+ try self.init(data: data)
31+ }
32+
33+ init(fromURL url: URL) throws {
34+ try self.init(data: try Data(contentsOf: url))
35+ }
36+
37+ func with(
38+ codingKeys: CodingKeysClass? = nil,
39+ name: String? = nil
40+ ) -> TopLevel {
41+ return TopLevel(
42+ codingKeys: codingKeys ?? self.codingKeys,
43+ name: name ?? self.name
44+ )
45+ }
46+
47+ func jsonData() throws -> Data {
48+ return try newJSONEncoder().encode(self)
49+ }
50+
51+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
52+ return String(data: try self.jsonData(), encoding: encoding)
53+ }
54+}
55+
56+// MARK: - CodingKeysClass
57+struct CodingKeysClass: Codable {
58+ let foo: String
59+
60+ enum CodingKeys: String, CodingKey {
61+ case foo = "foo"
62+ }
63+}
64+
65+// MARK: CodingKeysClass convenience initializers and mutators
66+
67+extension CodingKeysClass {
68+ init(data: Data) throws {
69+ self = try newJSONDecoder().decode(CodingKeysClass.self, from: data)
70+ }
71+
72+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
73+ guard let data = json.data(using: encoding) else {
74+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
75+ }
76+ try self.init(data: data)
77+ }
78+
79+ init(fromURL url: URL) throws {
80+ try self.init(data: try Data(contentsOf: url))
81+ }
82+
83+ func with(
84+ foo: String? = nil
85+ ) -> CodingKeysClass {
86+ return CodingKeysClass(
87+ foo: foo ?? self.foo
88+ )
89+ }
90+
91+ func jsonData() throws -> Data {
92+ return try newJSONEncoder().encode(self)
93+ }
94+
95+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
96+ return String(data: try self.jsonData(), encoding: encoding)
97+ }
98+}
99+
100+// MARK: - Helper functions for creating encoders and decoders
101+
102+func newJSONDecoder() -> JSONDecoder {
103+ let decoder = JSONDecoder()
104+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
105+ let container = try decoder.singleValueContainer()
106+ let dateStr = try container.decode(String.self)
107+
108+ let formatter = DateFormatter()
109+ formatter.calendar = Calendar(identifier: .iso8601)
110+ formatter.locale = Locale(identifier: "en_US_POSIX")
111+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
112+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
113+ if let date = formatter.date(from: dateStr) {
114+ return date
115+ }
116+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
117+ if let date = formatter.date(from: dateStr) {
118+ return date
119+ }
120+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
121+ })
122+ return decoder
123+}
124+
125+func newJSONEncoder() -> JSONEncoder {
126+ let encoder = JSONEncoder()
127+ let formatter = DateFormatter()
128+ formatter.calendar = Calendar(identifier: .iso8601)
129+ formatter.locale = Locale(identifier: "en_US_POSIX")
130+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
131+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
132+ encoder.dateEncodingStrategy = .formatted(formatter)
133+ return encoder
134+}
Aschema-swiftnest-types-true--d03bdf4b0ab1 / quicktype.swift+130 −0
@@ -0,0 +1,130 @@
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 codingKeys: TopLevel.CodingKeysClass
11+ let name: String
12+
13+ enum CodingKeys: String, CodingKey {
14+ case codingKeys = "coding-keys"
15+ case name = "name"
16+ }
17+
18+ struct CodingKeysClass: Codable {
19+ let foo: String
20+
21+ enum CodingKeys: String, CodingKey {
22+ case foo = "foo"
23+ }
24+ }
25+
26+ // MARK: Helper functions for creating encoders and decoders
27+ static func newJSONDecoder() -> JSONDecoder {
28+ let decoder = JSONDecoder()
29+ decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in
30+ let container = try decoder.singleValueContainer()
31+ let dateStr = try container.decode(String.self)
32+
33+ let formatter = DateFormatter()
34+ formatter.calendar = Calendar(identifier: .iso8601)
35+ formatter.locale = Locale(identifier: "en_US_POSIX")
36+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
37+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"
38+ if let date = formatter.date(from: dateStr) {
39+ return date
40+ }
41+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
42+ if let date = formatter.date(from: dateStr) {
43+ return date
44+ }
45+ throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date"))
46+ })
47+ return decoder
48+ }
49+
50+ static func newJSONEncoder() -> JSONEncoder {
51+ let encoder = JSONEncoder()
52+ let formatter = DateFormatter()
53+ formatter.calendar = Calendar(identifier: .iso8601)
54+ formatter.locale = Locale(identifier: "en_US_POSIX")
55+ formatter.timeZone = TimeZone(secondsFromGMT: 0)
56+ formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX"
57+ encoder.dateEncodingStrategy = .formatted(formatter)
58+ return encoder
59+ }
60+}
61+
62+// MARK: TopLevel convenience initializers and mutators
63+
64+extension TopLevel {
65+ init(data: Data) throws {
66+ self = try TopLevel.newJSONDecoder().decode(TopLevel.self, from: data)
67+ }
68+
69+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
70+ guard let data = json.data(using: encoding) else {
71+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
72+ }
73+ try self.init(data: data)
74+ }
75+
76+ init(fromURL url: URL) throws {
77+ try self.init(data: try Data(contentsOf: url))
78+ }
79+
80+ func with(
81+ codingKeys: TopLevel.CodingKeysClass? = nil,
82+ name: String? = nil
83+ ) -> TopLevel {
84+ return TopLevel(
85+ codingKeys: codingKeys ?? self.codingKeys,
86+ name: name ?? self.name
87+ )
88+ }
89+
90+ func jsonData() throws -> Data {
91+ return try TopLevel.newJSONEncoder().encode(self)
92+ }
93+
94+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
95+ return String(data: try self.jsonData(), encoding: encoding)
96+ }
97+}
98+
99+extension TopLevel.CodingKeysClass {
100+ init(data: Data) throws {
101+ self = try TopLevel.newJSONDecoder().decode(TopLevel.CodingKeysClass.self, from: data)
102+ }
103+
104+ init(_ json: String, using encoding: String.Encoding = .utf8) throws {
105+ guard let data = json.data(using: encoding) else {
106+ throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
107+ }
108+ try self.init(data: data)
109+ }
110+
111+ init(fromURL url: URL) throws {
112+ try self.init(data: try Data(contentsOf: url))
113+ }
114+
115+ func with(
116+ foo: String? = nil
117+ ) -> TopLevel.CodingKeysClass {
118+ return TopLevel.CodingKeysClass(
119+ foo: foo ?? self.foo
120+ )
121+ }
122+
123+ func jsonData() throws -> Data {
124+ return try TopLevel.newJSONEncoder().encode(self)
125+ }
126+
127+ func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
128+ return String(data: try self.jsonData(), encoding: encoding)
129+ }
130+}
Aschema-typescript-zoddefault / TopLevel.ts+13 −0
@@ -0,0 +1,13 @@
1+import * as z from "zod";
2+
3+
4+export const CodingKeysSchema = z.object({
5+ "foo": z.string(),
6+});
7+export type CodingKeys = z.infer<typeof CodingKeysSchema>;
8+
9+export const TopLevelSchema = z.object({
10+ "coding-keys": CodingKeysSchema,
11+ "name": z.string(),
12+});
13+export type TopLevel = z.infer<typeof TopLevelSchema>;
Aschema-typescriptdefault / TopLevel.ts+194 −0
@@ -0,0 +1,194 @@
1+// To parse this data:
2+//
3+// import { Convert, TopLevel } from "./TopLevel";
4+//
5+// const topLevel = Convert.toTopLevel(json);
6+//
7+// These functions will throw an error if the JSON doesn't
8+// match the expected interface, even if the JSON is valid.
9+
10+export interface TopLevel {
11+ "coding-keys": CodingKeys;
12+ name: string;
13+ [property: string]: unknown;
14+}
15+
16+export interface CodingKeys {
17+ foo: string;
18+ [property: string]: unknown;
19+}
20+
21+// Converts JSON strings to/from your types
22+// and asserts the results of JSON.parse at runtime
23+export class Convert {
24+ public static toTopLevel(json: string): TopLevel {
25+ return cast(JSON.parse(json), r("TopLevel"));
26+ }
27+
28+ public static topLevelToJson(value: TopLevel): string {
29+ return JSON.stringify(uncast(value, r("TopLevel")), null, 2);
30+ }
31+}
32+
33+function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
34+ const prettyTyp = prettyTypeName(typ);
35+ const parentText = parent ? ` on ${parent}` : '';
36+ const keyText = key ? ` for key "${key}"` : '';
37+ throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
38+}
39+
40+function prettyTypeName(typ: any): string {
41+ if (Array.isArray(typ)) {
42+ if (typ.length === 2 && typ[0] === undefined) {
43+ return `an optional ${prettyTypeName(typ[1])}`;
44+ } else {
45+ return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
46+ }
47+ } else if (typeof typ === "object" && typ.literal !== undefined) {
48+ return typ.literal;
49+ } else {
50+ return typeof typ;
51+ }
52+}
53+
54+function jsonToJSProps(typ: any): any {
55+ if (typ.jsonToJS === undefined) {
56+ const map: any = {};
57+ typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
58+ typ.jsonToJS = map;
59+ }
60+ return typ.jsonToJS;
61+}
62+
63+function jsToJSONProps(typ: any): any {
64+ if (typ.jsToJSON === undefined) {
65+ const map: any = {};
66+ typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
67+ typ.jsToJSON = map;
68+ }
69+ return typ.jsToJSON;
70+}
71+
72+function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
73+ function transformPrimitive(typ: string, val: any): any {
74+ if (typeof typ === typeof val) return val;
75+ return invalidValue(typ, val, key, parent);
76+ }
77+
78+ function transformUnion(typs: any[], val: any): any {
79+ // val must validate against one typ in typs
80+ const l = typs.length;
81+ for (let i = 0; i < l; i++) {
82+ const typ = typs[i];
83+ try {
84+ return transform(val, typ, getProps);
85+ } catch (_) {}
86+ }
87+ return invalidValue(typs, val, key, parent);
88+ }
89+
90+ function transformEnum(cases: string[], val: any): any {
91+ if (cases.indexOf(val) !== -1) return val;
92+ return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
93+ }
94+
95+ function transformArray(typ: any, val: any): any {
96+ // val must be an array with no invalid elements
97+ if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
98+ return val.map(el => transform(el, typ, getProps));
99+ }
100+
101+ function transformDate(val: any): any {
102+ if (val === null) {
103+ return null;
104+ }
105+ const d = new Date(val);
106+ if (isNaN(d.valueOf())) {
107+ return invalidValue(l("Date"), val, key, parent);
108+ }
109+ return d;
110+ }
111+
112+ function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
113+ if (val === null || typeof val !== "object" || Array.isArray(val)) {
114+ return invalidValue(l(ref || "object"), val, key, parent);
115+ }
116+ const result: any = {};
117+ Object.getOwnPropertyNames(props).forEach(key => {
118+ const prop = props[key];
119+ const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
120+ result[prop.key] = transform(v, prop.typ, getProps, key, ref);
121+ });
122+ Object.getOwnPropertyNames(val).forEach(key => {
123+ if (!Object.prototype.hasOwnProperty.call(props, key)) {
124+ result[key] = transform(val[key], additional, getProps, key, ref);
125+ }
126+ });
127+ return result;
128+ }
129+
130+ if (typ === "any") return val;
131+ if (typ === null) {
132+ if (val === null) return val;
133+ return invalidValue(typ, val, key, parent);
134+ }
135+ if (typ === false) return invalidValue(typ, val, key, parent);
136+ let ref: any = undefined;
137+ while (typeof typ === "object" && typ.ref !== undefined) {
138+ ref = typ.ref;
139+ typ = typeMap[typ.ref];
140+ }
141+ if (Array.isArray(typ)) return transformEnum(typ, val);
142+ if (typeof typ === "object") {
143+ return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
144+ : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
145+ : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
146+ : invalidValue(typ, val, key, parent);
147+ }
148+ // Numbers can be parsed by Date but shouldn't be.
149+ if (typ === Date && typeof val !== "number") return transformDate(val);
150+ return transformPrimitive(typ, val);
151+}
152+
153+function cast<T>(val: any, typ: any): T {
154+ return transform(val, typ, jsonToJSProps);
155+}
156+
157+function uncast<T>(val: T, typ: any): any {
158+ return transform(val, typ, jsToJSONProps);
159+}
160+
161+function l(typ: any) {
162+ return { literal: typ };
163+}
164+
165+function a(typ: any) {
166+ return { arrayItems: typ };
167+}
168+
169+function u(...typs: any[]) {
170+ return { unionMembers: typs };
171+}
172+
173+function o(props: any[], additional: any) {
174+ return { props, additional };
175+}
176+
177+function m(additional: any) {
178+ const props: any[] = [];
179+ return { props, additional };
180+}
181+
182+function r(name: string) {
183+ return { ref: name };
184+}
185+
186+const typeMap: any = {
187+ "TopLevel": o([
188+ { json: "coding-keys", js: "coding-keys", typ: r("CodingKeys") },
189+ { json: "name", js: "name", typ: "" },
190+ ], "any"),
191+ "CodingKeys": o([
192+ { json: "foo", js: "foo", typ: "" },
193+ ], "any"),
194+};
No generated files match these filters.