Generated-output differences

quicktype output changed between the PR base and tested PR merge revisions.
← Back to the pull request
5test cases
5files differ
0modified
1new
4deleted
12,312changed lines
+94 −12,218insertions / deletions
Base 4fae346ba5a108350e23f153a6e0d2edc996fc3f · PR merge aa6a5f41eef3ceb120f747084de0fe52d62294d1 · Head e19263cff4c844f1fd120e1ee9a50ce55809617d · raw patch
Test case

test/inputs/json/priority/combinations1.json

1 generated file · +0 −2,838
Dswiftcoding-keys-protocol-CaseIterable--169323764eaa / quicktype.swift+0 −2,838
@@ -1,2838 +0,0 @@
1-// This file was generated from JSON Schema using quicktype, do not modify it directly.
2-// To parse the JSON, add this file to your project and do:
3-//
4-// let topLevel = try TopLevel(json)
5-
6-import Foundation
7-
8-// MARK: - TopLevel
9-struct TopLevel: Codable {
10- let centrodesmose: String
11- let cerograph: [CerographElement]
12- let chemotherapeutics: [ChemotherapeuticElement]
13- let cimelia: [CimeliaElement]
14- let citrated: Int
15- let clinodome: [Clinodome]
16- let coadjust: [CoadjustElement]
17- let consilience: [Consilience]
18- let constructor: [Constructor]
19- let continuative: [Continuative]
20- let credulity: [CredulityElement]
21- let creviced: [Creviced]
22- let cubiculum: [[Int?]]
23- let deruralize: [DeruralizeElement]
24- let diaereses: [DiaereseElement]
25- let dissolution: [[JSONNull?]?]
26- let downstroke: [Downstroke]
27- let electrotautomerism: [Double?]
28- let eleutheromania: [Eleutheromania]
29- let encrust: Encrust
30- let entomoid: [Entomoid]
31- let epipaleolithic: [Epipaleolithic]
32- let expropriable: [Expropriable]
33- let faggingly: [FagginglyElement]
34- let fenks: [FenkElement]
35- let flagmaking: [FlagmakingElement]
36- let fluorometer: [Fluorometer]
37- let fulsome: [Int?]
38- let fuzzy: [Fuzzy]
39- let gardenwards: [Gardenward]
40- let generalissimo: [Generalissimo]
41- let habeas: [[String: Int]?]
42- let hemicrystalline: [Hemicrystalline]
43- let hemocoele: [HemocoeleElement]
44- let hoister: [Hoister]
45- let hyperpiesis: [Hyperpiesi]
46- let hyppish: [Hyppish]
47- let idealizer: [Idealizer]
48- let incrustator: [Incrustator]
49- let intentiveness: [Intentiveness]
50- let interacinar: Interacinar
51- let intercorrelation: [[Int]?]
52- let jacutinga: [Jacutinga]
53-
54- enum CodingKeys: String, CodingKey, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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-class JSONNull: Codable, Hashable {
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-}
Test case

test/inputs/json/priority/combinations2.json

1 generated file · +0 −2,602
Dswiftcoding-keys-protocol-CaseIterable--169323764eaa / quicktype.swift+0 −2,602
@@ -1,2602 +0,0 @@
1-// This file was generated from JSON Schema using quicktype, do not modify it directly.
2-// To parse the JSON, add this file to your project and do:
3-//
4-// let topLevel = try TopLevel(json)
5-
6-import Foundation
7-
8-// MARK: - TopLevel
9-struct TopLevel: Codable {
10- let abranchiata: [Abranchiata]
11- let academe: [Academe]
12- let acquirable: [Acquirable]
13- let aerometry: [Aerometry]
14- let alexin: [Alexin]
15- let alleviate: [AlleviateElement]
16- let amaas: [Amaa]
17- let ambassage: [Ambassage]
18- let amphithyron: [Amphithyron?]
19- let andriana: [String?]
20- let ankee: [AnkeeElement]
21- let annihilator: [[String: Int?]?]
22- let annulose: JSONNull?
23- let ansarie: [AnsarieElement]
24- let aphasia: [Aphasia]
25- let asprawl: [Asprawl]
26- let attractive: [Bool?]
27- let barksome: [String: Int]
28- let bedesman: [Bedesman]
29- let belard: [Belard]
30- let bocking: [Bocking]
31- let brawlingly: [Brawlingly]
32- let brookie: [Brookie]
33- let bumboatman: [Bumboatman]
34- let bystreet: [JSONNull?]
35- let calaverite: [Calaverite]
36- let catallactic: [Catallactic]
37- let cemental: [Cemental]
38- let chytridiaceae: [ChytridiaceaeElement]
39- let discordia: [DiscordiaElement]
40- let endomyces: [Endomyce]
41- let epinephelidae: [Epinephelidae]
42- let eupatorium: [Eupatorium]
43- let gryphosaurus: [GryphosaurusElement]
44- let koryak: [Koryak]
45- let lavinia: [LaviniaElement]
46- let oskar: [OskarElement]
47- let rebecca: [RebeccaElement]
48- let rhomboganoidei: [Rhomboganoidei]
49- let rigsmal: Bool
50- let ruellia: [Ruellia]
51- let school: [School]
52- let shakespearolater: [Shakespearolater]
53- let svan: [Double]
54- let wayao: [String: Double]
55-
56- enum CodingKeys: String, CodingKey, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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-class JSONNull: Codable, Hashable {
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-}
Test case

test/inputs/json/priority/combinations3.json

1 generated file · +0 −3,137
Dswiftcoding-keys-protocol-CaseIterable--169323764eaa / quicktype.swift+0 −3,137
@@ -1,3137 +0,0 @@
1-// This file was generated from JSON Schema using quicktype, do not modify it directly.
2-// To parse the JSON, add this file to your project and do:
3-//
4-// let topLevel = try TopLevel(json)
5-
6-import Foundation
7-
8-// MARK: - TopLevel
9-struct TopLevel: Codable {
10- let juror: [JurorElement]
11- let kongoni: [Kongoni]
12- let ladronism: [LadronismElement]
13- let landlubberly: [LandlubberlyElement]
14- let listener: [Listener]
15- let lupus: [LupusElement]
16- let maslin: [Maslin]
17- let monazite: [MonaziteElement]
18- let monoliteral: [Monoliteral]
19- let monotheistically: [MonotheisticallyElement]
20- let montage: [Montage]
21- let moralness: [Moralness]
22- let mowra: [MonaziteClass?]
23- let mulishly: [Mulishly]
24- let myoscope: [Myoscope]
25- let nach: [[Int?]?]
26- let neuromastic: [Neuromastic]
27- let noncontributing: [Noncontributing]
28- let nonnervous: [Nonnervous]
29- let nonvaluation: [Nonvaluation]
30- let occupationalist: [OccupationalistElement]
31- let outrival: [OutrivalElement]
32- let paleographically: [Paleographically]
33- let pamphletwise: [Pamphletwise]
34- let pediatrics: [Pediatric]
35- let perceptive: [Bool]
36- let piaculum: [PiaculumElement]
37- let piccadilly: [Piccadilly]
38- let piffler: [Piffler]
39- let pithful: [Pithful]
40- let placuntitis: [Placuntiti]
41- let plectopterous: [Plectopterous]
42- let pneumocele: [Pneumocele?]
43- let poliorcetic: [Poliorcetic]
44- let poormaster: [Poormaster]
45- let potwhisky: [PotwhiskyElement]
46- let practicalizer: [Practicalizer]
47- let prefreshman: [PrefreshmanElement]
48- let prehensility: [Prehensility]
49- let prevoidance: [Prevoidance]
50- let probant: [[String: Int?]]
51- let protext: [Protext]
52-
53- enum CodingKeys: String, CodingKey, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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-class JSONNull: Codable, Hashable {
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-}
Test case

test/inputs/json/priority/combinations4.json

1 generated file · +0 −3,641
Dswiftcoding-keys-protocol-CaseIterable--169323764eaa / quicktype.swift+0 −3,641
@@ -1,3641 +0,0 @@
1-// This file was generated from JSON Schema using quicktype, do not modify it directly.
2-// To parse the JSON, add this file to your project and do:
3-//
4-// let topLevel = try TopLevel(json)
5-
6-import Foundation
7-
8-// MARK: - TopLevel
9-struct TopLevel: Codable {
10- let protrusive: [Protrusive]
11- let pulpitism: [PulpitismElement]
12- let pyodermia: [PyodermiaElement]
13- let quebrachine: [QuebrachineElement]
14- let querier: [Querier]
15- let rebarbative: [Rebarbative]
16- let reimagine: [Reimagine]
17- let ressaut: Ressaut
18- let retrocervical: [Retrocervical]
19- let revert: [Revert]
20- let rewrite: [RewriteElement]
21- let saccoderm: [Saccoderm]
22- let santir: [SantirElement]
23- let saprophilous: [Saprophilous]
24- let saxten: [SaxtenElement]
25- let scatty: [Scatty?]
26- let scoffer: [Scoffer]
27- let scrampum: [Scrampum]
28- let semantic: Double
29- let serpentinic: [Serpentinic]
30- let shadowable: [Shadowable]
31- let sistering: [SisteringElement]
32- let staghunting: [Staghunting]
33- let stagmometer: [Stagmometer]
34- let stimulability: [Stimulability]
35- let strangleable: [Strangleable]
36- let strenuosity: [StrenuosityElement]
37- let tabaxir: [Tabaxir]
38- let talpiform: [Talpiform]
39- let thwack: [Thwack]
40- let to: [Double?]
41- let tortricine: [Tortricine]
42- let truantcy: [TruantcyElement]
43- let turgesce: [String]
44- let unbeginning: [Unbeginning]
45- let underdunged: [Double]
46- let undesirability: [Undesirability]
47- let unerasing: [Unerasing]
48- let unguentarium: [Unguentarium]
49- let unimpeachably: [UnimpeachablyElement]
50- let unmortgaged: [Unmortgaged]
51- let unobstructed: [Unobstructed]
52- let unreceptivity: [Unreceptivity]
53- let unsatisfactoriness: [Unsatisfactoriness]
54- let unsecurity: [Int]
55- let unstressed: [UnstressedElement]
56- let untasked: [Untasked]
57- let unvarying: [Unvarying]
58- let vehemently: [Vehemently]
59- let warriorship: [String: Bool]
60- let whitepot: [Whitepot]
61- let wrothy: [WrothyElement]
62-
63- enum CodingKeys: String, CodingKey, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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, CaseIterable {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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 {
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 {
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 {
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 {
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 {
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 {
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, CaseIterable {
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-class JSONNull: Codable, Hashable {
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-}
Test case

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

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