Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
4test cases
9files differ
0modified
9new
0deleted
29,099changed lines
+29,099 −0insertions / deletions
Base 66df8a7480383ad7d4784464b395df83fd482c7f · PR merge f4b053127642fce4718335b70cbba44004f33948 · Head 4800d11d882206832a236c3011136ec34576ade0 · raw patch
Test case

test/inputs/json/priority/combinations1.json

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

test/inputs/json/priority/combinations2.json

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

test/inputs/json/priority/combinations3.json

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

test/inputs/json/priority/combinations4.json

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