diff --git a/head/swift-sendable/test/inputs/json/priority/combinations1.json/default/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations1.json/default/quicktype.swift new file mode 100644 index 0000000..3bfe783 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations1.json/default/quicktype.swift @@ -0,0 +1,2838 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Sendable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [Jacutinga] + + enum CodingKeys: String, CodingKey { + case centrodesmose = "centrodesmose" + case cerograph = "cerograph" + case chemotherapeutics = "chemotherapeutics" + case cimelia = "cimelia" + case citrated = "citrated" + case clinodome = "clinodome" + case coadjust = "coadjust" + case consilience = "consilience" + case constructor = "constructor" + case continuative = "continuative" + case credulity = "credulity" + case creviced = "creviced" + case cubiculum = "cubiculum" + case deruralize = "deruralize" + case diaereses = "diaereses" + case dissolution = "dissolution" + case downstroke = "downstroke" + case electrotautomerism = "electrotautomerism" + case eleutheromania = "eleutheromania" + case encrust = "encrust" + case entomoid = "entomoid" + case epipaleolithic = "epipaleolithic" + case expropriable = "expropriable" + case faggingly = "faggingly" + case fenks = "fenks" + case flagmaking = "flagmaking" + case fluorometer = "fluorometer" + case fulsome = "fulsome" + case fuzzy = "fuzzy" + case gardenwards = "gardenwards" + case generalissimo = "generalissimo" + case habeas = "habeas" + case hemicrystalline = "hemicrystalline" + case hemocoele = "hemocoele" + case hoister = "hoister" + case hyperpiesis = "hyperpiesis" + case hyppish = "hyppish" + case idealizer = "idealizer" + case incrustator = "incrustator" + case intentiveness = "intentiveness" + case interacinar = "interacinar" + case intercorrelation = "intercorrelation" + case jacutinga = "jacutinga" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [Jacutinga]? = nil + ) -> TopLevel { + return TopLevel( + centrodesmose: centrodesmose ?? self.centrodesmose, + cerograph: cerograph ?? self.cerograph, + chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics, + cimelia: cimelia ?? self.cimelia, + citrated: citrated ?? self.citrated, + clinodome: clinodome ?? self.clinodome, + coadjust: coadjust ?? self.coadjust, + consilience: consilience ?? self.consilience, + constructor: constructor ?? self.constructor, + continuative: continuative ?? self.continuative, + credulity: credulity ?? self.credulity, + creviced: creviced ?? self.creviced, + cubiculum: cubiculum ?? self.cubiculum, + deruralize: deruralize ?? self.deruralize, + diaereses: diaereses ?? self.diaereses, + dissolution: dissolution ?? self.dissolution, + downstroke: downstroke ?? self.downstroke, + electrotautomerism: electrotautomerism ?? self.electrotautomerism, + eleutheromania: eleutheromania ?? self.eleutheromania, + encrust: encrust ?? self.encrust, + entomoid: entomoid ?? self.entomoid, + epipaleolithic: epipaleolithic ?? self.epipaleolithic, + expropriable: expropriable ?? self.expropriable, + faggingly: faggingly ?? self.faggingly, + fenks: fenks ?? self.fenks, + flagmaking: flagmaking ?? self.flagmaking, + fluorometer: fluorometer ?? self.fluorometer, + fulsome: fulsome ?? self.fulsome, + fuzzy: fuzzy ?? self.fuzzy, + gardenwards: gardenwards ?? self.gardenwards, + generalissimo: generalissimo ?? self.generalissimo, + habeas: habeas ?? self.habeas, + hemicrystalline: hemicrystalline ?? self.hemicrystalline, + hemocoele: hemocoele ?? self.hemocoele, + hoister: hoister ?? self.hoister, + hyperpiesis: hyperpiesis ?? self.hyperpiesis, + hyppish: hyppish ?? self.hyppish, + idealizer: idealizer ?? self.idealizer, + incrustator: incrustator ?? self.incrustator, + intentiveness: intentiveness ?? self.intentiveness, + interacinar: interacinar ?? self.interacinar, + intercorrelation: intercorrelation ?? self.intercorrelation, + jacutinga: jacutinga ?? self.jacutinga + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable, Sendable { + case cerographClass(CerographClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CerographClass.self) { + self = .cerographClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cerographClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CerographClass +struct CerographClass: Codable, Sendable { + let apotropaion: JSONNull? + let casuary: JSONNull? + let creaker: JSONNull? + let disqualification: JSONNull? + let imperatorious: JSONNull? + let impermeabilize: JSONNull? + let metastoma: JSONNull? + let noctidiurnal: JSONNull? + let nonreserve: JSONNull? + let ophthalmotonometry: JSONNull? + let pailful: JSONNull? + let pigfish: JSONNull? + let pongee: JSONNull? + let prosodical: JSONNull? + let scrofuloderm: JSONNull? + let storekeeping: JSONNull? + let therologist: JSONNull? + let tolowa: JSONNull? + let tradeful: JSONNull? + let unriveting: JSONNull? + + enum CodingKeys: String, CodingKey { + case apotropaion = "apotropaion" + case casuary = "casuary" + case creaker = "creaker" + case disqualification = "disqualification" + case imperatorious = "imperatorious" + case impermeabilize = "impermeabilize" + case metastoma = "metastoma" + case noctidiurnal = "noctidiurnal" + case nonreserve = "nonreserve" + case ophthalmotonometry = "ophthalmotonometry" + case pailful = "pailful" + case pigfish = "pigfish" + case pongee = "pongee" + case prosodical = "prosodical" + case scrofuloderm = "scrofuloderm" + case storekeeping = "storekeeping" + case therologist = "therologist" + case tolowa = "Tolowa" + case tradeful = "tradeful" + case unriveting = "unriveting" + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CerographClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apotropaion: JSONNull?? = nil, + casuary: JSONNull?? = nil, + creaker: JSONNull?? = nil, + disqualification: JSONNull?? = nil, + imperatorious: JSONNull?? = nil, + impermeabilize: JSONNull?? = nil, + metastoma: JSONNull?? = nil, + noctidiurnal: JSONNull?? = nil, + nonreserve: JSONNull?? = nil, + ophthalmotonometry: JSONNull?? = nil, + pailful: JSONNull?? = nil, + pigfish: JSONNull?? = nil, + pongee: JSONNull?? = nil, + prosodical: JSONNull?? = nil, + scrofuloderm: JSONNull?? = nil, + storekeeping: JSONNull?? = nil, + therologist: JSONNull?? = nil, + tolowa: JSONNull?? = nil, + tradeful: JSONNull?? = nil, + unriveting: JSONNull?? = nil + ) -> CerographClass { + return CerographClass( + apotropaion: apotropaion ?? self.apotropaion, + casuary: casuary ?? self.casuary, + creaker: creaker ?? self.creaker, + disqualification: disqualification ?? self.disqualification, + imperatorious: imperatorious ?? self.imperatorious, + impermeabilize: impermeabilize ?? self.impermeabilize, + metastoma: metastoma ?? self.metastoma, + noctidiurnal: noctidiurnal ?? self.noctidiurnal, + nonreserve: nonreserve ?? self.nonreserve, + ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry, + pailful: pailful ?? self.pailful, + pigfish: pigfish ?? self.pigfish, + pongee: pongee ?? self.pongee, + prosodical: prosodical ?? self.prosodical, + scrofuloderm: scrofuloderm ?? self.scrofuloderm, + storekeeping: storekeeping ?? self.storekeeping, + therologist: therologist ?? self.therologist, + tolowa: tolowa ?? self.tolowa, + tradeful: tradeful ?? self.tradeful, + unriveting: unriveting ?? self.unriveting + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable, Sendable { + case chemotherapeuticClass(ChemotherapeuticClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(ChemotherapeuticClass.self) { + self = .chemotherapeuticClass(x) + return + } + throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .chemotherapeuticClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +// MARK: - ChemotherapeuticClass +struct ChemotherapeuticClass: Codable, Sendable { + let angioneurotic: JSONNull? + let availment: JSONNull? + let bladelet: JSONNull? + let catharticalness: Double? + let caulis: JSONNull? + let chalcus: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let enteradenological: JSONNull? + let homocerc: Bool? + let imporosity: JSONNull? + let insistently: JSONNull? + let intraparietal: JSONNull? + let ivied: JSONNull? + let maureen: JSONNull? + let nonbookish: JSONNull? + let nostochine: JSONNull? + let nutcracker: JSONNull? + let ofttimes: JSONNull? + let phenocryst: JSONNull? + let precoincident: JSONNull? + let ramiferous: JSONNull? + let stagmometer: JSONNull? + let tetherball: JSONNull? + let unshy: JSONNull? + + enum CodingKeys: String, CodingKey { + case angioneurotic = "angioneurotic" + case availment = "availment" + case bladelet = "bladelet" + case catharticalness = "catharticalness" + case caulis = "caulis" + case chalcus = "chalcus" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case enteradenological = "enteradenological" + case homocerc = "homocerc" + case imporosity = "imporosity" + case insistently = "insistently" + case intraparietal = "intraparietal" + case ivied = "ivied" + case maureen = "Maureen" + case nonbookish = "nonbookish" + case nostochine = "nostochine" + case nutcracker = "nutcracker" + case ofttimes = "ofttimes" + case phenocryst = "phenocryst" + case precoincident = "precoincident" + case ramiferous = "ramiferous" + case stagmometer = "stagmometer" + case tetherball = "tetherball" + case unshy = "unshy" + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + angioneurotic: JSONNull?? = nil, + availment: JSONNull?? = nil, + bladelet: JSONNull?? = nil, + catharticalness: Double?? = nil, + caulis: JSONNull?? = nil, + chalcus: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + enteradenological: JSONNull?? = nil, + homocerc: Bool?? = nil, + imporosity: JSONNull?? = nil, + insistently: JSONNull?? = nil, + intraparietal: JSONNull?? = nil, + ivied: JSONNull?? = nil, + maureen: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nostochine: JSONNull?? = nil, + nutcracker: JSONNull?? = nil, + ofttimes: JSONNull?? = nil, + phenocryst: JSONNull?? = nil, + precoincident: JSONNull?? = nil, + ramiferous: JSONNull?? = nil, + stagmometer: JSONNull?? = nil, + tetherball: JSONNull?? = nil, + unshy: JSONNull?? = nil + ) -> ChemotherapeuticClass { + return ChemotherapeuticClass( + angioneurotic: angioneurotic ?? self.angioneurotic, + availment: availment ?? self.availment, + bladelet: bladelet ?? self.bladelet, + catharticalness: catharticalness ?? self.catharticalness, + caulis: caulis ?? self.caulis, + chalcus: chalcus ?? self.chalcus, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + enteradenological: enteradenological ?? self.enteradenological, + homocerc: homocerc ?? self.homocerc, + imporosity: imporosity ?? self.imporosity, + insistently: insistently ?? self.insistently, + intraparietal: intraparietal ?? self.intraparietal, + ivied: ivied ?? self.ivied, + maureen: maureen ?? self.maureen, + nonbookish: nonbookish ?? self.nonbookish, + nostochine: nostochine ?? self.nostochine, + nutcracker: nutcracker ?? self.nutcracker, + ofttimes: ofttimes ?? self.ofttimes, + phenocryst: phenocryst ?? self.phenocryst, + precoincident: precoincident ?? self.precoincident, + ramiferous: ramiferous ?? self.ramiferous, + stagmometer: stagmometer ?? self.stagmometer, + tetherball: tetherball ?? self.tetherball, + unshy: unshy ?? self.unshy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CimeliaClass +struct CimeliaClass: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CimeliaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> CimeliaClass { + return CimeliaClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Clinodome: Codable, Sendable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CoadjustElement: Codable, Sendable { + case coadjustClass(CoadjustClass) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CoadjustClass.self) { + self = .coadjustClass(x) + return + } + throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .coadjustClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +// MARK: - CoadjustClass +struct CoadjustClass: Codable, Sendable { + let amidosulphonal: JSONNull? + let benny: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ensnare: JSONNull? + let homocerc: Bool? + let hybridizer: JSONNull? + let leastwise: JSONNull? + let lof: JSONNull? + let monkhood: JSONNull? + let netherlandish: JSONNull? + let nonbookish: JSONNull? + let peonism: JSONNull? + let phonelescope: JSONNull? + let porphyrogeniture: JSONNull? + let preindemnify: JSONNull? + let rosal: JSONNull? + let scalenous: JSONNull? + let scopine: JSONNull? + let sedaceae: JSONNull? + let suberinize: JSONNull? + let symbiot: JSONNull? + let tablefellow: JSONNull? + let unchargeable: JSONNull? + + enum CodingKeys: String, CodingKey { + case amidosulphonal = "amidosulphonal" + case benny = "Benny" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ensnare = "ensnare" + case homocerc = "homocerc" + case hybridizer = "hybridizer" + case leastwise = "leastwise" + case lof = "lof" + case monkhood = "monkhood" + case netherlandish = "Netherlandish" + case nonbookish = "nonbookish" + case peonism = "peonism" + case phonelescope = "Phonelescope" + case porphyrogeniture = "porphyrogeniture" + case preindemnify = "preindemnify" + case rosal = "rosal" + case scalenous = "scalenous" + case scopine = "scopine" + case sedaceae = "Sedaceae" + case suberinize = "suberinize" + case symbiot = "symbiot" + case tablefellow = "tablefellow" + case unchargeable = "unchargeable" + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CoadjustClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amidosulphonal: JSONNull?? = nil, + benny: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ensnare: JSONNull?? = nil, + homocerc: Bool?? = nil, + hybridizer: JSONNull?? = nil, + leastwise: JSONNull?? = nil, + lof: JSONNull?? = nil, + monkhood: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + peonism: JSONNull?? = nil, + phonelescope: JSONNull?? = nil, + porphyrogeniture: JSONNull?? = nil, + preindemnify: JSONNull?? = nil, + rosal: JSONNull?? = nil, + scalenous: JSONNull?? = nil, + scopine: JSONNull?? = nil, + sedaceae: JSONNull?? = nil, + suberinize: JSONNull?? = nil, + symbiot: JSONNull?? = nil, + tablefellow: JSONNull?? = nil, + unchargeable: JSONNull?? = nil + ) -> CoadjustClass { + return CoadjustClass( + amidosulphonal: amidosulphonal ?? self.amidosulphonal, + benny: benny ?? self.benny, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ensnare: ensnare ?? self.ensnare, + homocerc: homocerc ?? self.homocerc, + hybridizer: hybridizer ?? self.hybridizer, + leastwise: leastwise ?? self.leastwise, + lof: lof ?? self.lof, + monkhood: monkhood ?? self.monkhood, + netherlandish: netherlandish ?? self.netherlandish, + nonbookish: nonbookish ?? self.nonbookish, + peonism: peonism ?? self.peonism, + phonelescope: phonelescope ?? self.phonelescope, + porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture, + preindemnify: preindemnify ?? self.preindemnify, + rosal: rosal ?? self.rosal, + scalenous: scalenous ?? self.scalenous, + scopine: scopine ?? self.scopine, + sedaceae: sedaceae ?? self.sedaceae, + suberinize: suberinize ?? self.suberinize, + symbiot: symbiot ?? self.symbiot, + tablefellow: tablefellow ?? self.tablefellow, + unchargeable: unchargeable ?? self.unchargeable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Consilience: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Constructor: Codable, Sendable { + case bool(Bool) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Continuative: Codable, Sendable { + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CredulityElement: Codable, Sendable { + case credulityClass(CredulityClass) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CredulityClass.self) { + self = .credulityClass(x) + return + } + throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .credulityClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - CredulityClass +struct CredulityClass: Codable, Sendable { + let ammonolytic: JSONNull? + let bushmaster: JSONNull? + let considering: JSONNull? + let consuetudinary: JSONNull? + let embarras: JSONNull? + let fineness: JSONNull? + let flaithship: JSONNull? + let flavia: JSONNull? + let gruffly: JSONNull? + let hedychium: JSONNull? + let leadwort: JSONNull? + let overseriously: JSONNull? + let parabola: JSONNull? + let pectinatodenticulate: JSONNull? + let popean: JSONNull? + let pornocrat: JSONNull? + let quadrisect: JSONNull? + let seriality: JSONNull? + let vamphorn: JSONNull? + let wharp: JSONNull? + + enum CodingKeys: String, CodingKey { + case ammonolytic = "ammonolytic" + case bushmaster = "bushmaster" + case considering = "considering" + case consuetudinary = "consuetudinary" + case embarras = "embarras" + case fineness = "fineness" + case flaithship = "flaithship" + case flavia = "Flavia" + case gruffly = "gruffly" + case hedychium = "Hedychium" + case leadwort = "leadwort" + case overseriously = "overseriously" + case parabola = "parabola" + case pectinatodenticulate = "pectinatodenticulate" + case popean = "Popean" + case pornocrat = "pornocrat" + case quadrisect = "quadrisect" + case seriality = "seriality" + case vamphorn = "vamphorn" + case wharp = "wharp" + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CredulityClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + ammonolytic: JSONNull?? = nil, + bushmaster: JSONNull?? = nil, + considering: JSONNull?? = nil, + consuetudinary: JSONNull?? = nil, + embarras: JSONNull?? = nil, + fineness: JSONNull?? = nil, + flaithship: JSONNull?? = nil, + flavia: JSONNull?? = nil, + gruffly: JSONNull?? = nil, + hedychium: JSONNull?? = nil, + leadwort: JSONNull?? = nil, + overseriously: JSONNull?? = nil, + parabola: JSONNull?? = nil, + pectinatodenticulate: JSONNull?? = nil, + popean: JSONNull?? = nil, + pornocrat: JSONNull?? = nil, + quadrisect: JSONNull?? = nil, + seriality: JSONNull?? = nil, + vamphorn: JSONNull?? = nil, + wharp: JSONNull?? = nil + ) -> CredulityClass { + return CredulityClass( + ammonolytic: ammonolytic ?? self.ammonolytic, + bushmaster: bushmaster ?? self.bushmaster, + considering: considering ?? self.considering, + consuetudinary: consuetudinary ?? self.consuetudinary, + embarras: embarras ?? self.embarras, + fineness: fineness ?? self.fineness, + flaithship: flaithship ?? self.flaithship, + flavia: flavia ?? self.flavia, + gruffly: gruffly ?? self.gruffly, + hedychium: hedychium ?? self.hedychium, + leadwort: leadwort ?? self.leadwort, + overseriously: overseriously ?? self.overseriously, + parabola: parabola ?? self.parabola, + pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate, + popean: popean ?? self.popean, + pornocrat: pornocrat ?? self.pornocrat, + quadrisect: quadrisect ?? self.quadrisect, + seriality: seriality ?? self.seriality, + vamphorn: vamphorn ?? self.vamphorn, + wharp: wharp ?? self.wharp + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Creviced: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum DeruralizeElement: Codable, Sendable { + case bool(Bool) + case deruralizeClass(DeruralizeClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(DeruralizeClass.self) { + self = .deruralizeClass(x) + return + } + throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .deruralizeClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DeruralizeClass +struct DeruralizeClass: Codable, Sendable { + let bockerel: JSONNull? + let boulder: JSONNull? + let churrus: JSONNull? + let counterdigged: JSONNull? + let dialogite: JSONNull? + let digenic: JSONNull? + let dunbird: JSONNull? + let ergatogyne: JSONNull? + let fiendful: JSONNull? + let jackrod: JSONNull? + let jehovistic: JSONNull? + let paninean: JSONNull? + let panther: JSONNull? + let placentigerous: JSONNull? + let romney: JSONNull? + let sparm: JSONNull? + let tocsin: JSONNull? + let unnicked: JSONNull? + let unstavable: JSONNull? + let windfirm: JSONNull? + + enum CodingKeys: String, CodingKey { + case bockerel = "bockerel" + case boulder = "boulder" + case churrus = "churrus" + case counterdigged = "counterdigged" + case dialogite = "dialogite" + case digenic = "digenic" + case dunbird = "dunbird" + case ergatogyne = "ergatogyne" + case fiendful = "fiendful" + case jackrod = "jackrod" + case jehovistic = "Jehovistic" + case paninean = "Paninean" + case panther = "panther" + case placentigerous = "placentigerous" + case romney = "Romney" + case sparm = "sparm" + case tocsin = "tocsin" + case unnicked = "unnicked" + case unstavable = "unstavable" + case windfirm = "windfirm" + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(DeruralizeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bockerel: JSONNull?? = nil, + boulder: JSONNull?? = nil, + churrus: JSONNull?? = nil, + counterdigged: JSONNull?? = nil, + dialogite: JSONNull?? = nil, + digenic: JSONNull?? = nil, + dunbird: JSONNull?? = nil, + ergatogyne: JSONNull?? = nil, + fiendful: JSONNull?? = nil, + jackrod: JSONNull?? = nil, + jehovistic: JSONNull?? = nil, + paninean: JSONNull?? = nil, + panther: JSONNull?? = nil, + placentigerous: JSONNull?? = nil, + romney: JSONNull?? = nil, + sparm: JSONNull?? = nil, + tocsin: JSONNull?? = nil, + unnicked: JSONNull?? = nil, + unstavable: JSONNull?? = nil, + windfirm: JSONNull?? = nil + ) -> DeruralizeClass { + return DeruralizeClass( + bockerel: bockerel ?? self.bockerel, + boulder: boulder ?? self.boulder, + churrus: churrus ?? self.churrus, + counterdigged: counterdigged ?? self.counterdigged, + dialogite: dialogite ?? self.dialogite, + digenic: digenic ?? self.digenic, + dunbird: dunbird ?? self.dunbird, + ergatogyne: ergatogyne ?? self.ergatogyne, + fiendful: fiendful ?? self.fiendful, + jackrod: jackrod ?? self.jackrod, + jehovistic: jehovistic ?? self.jehovistic, + paninean: paninean ?? self.paninean, + panther: panther ?? self.panther, + placentigerous: placentigerous ?? self.placentigerous, + romney: romney ?? self.romney, + sparm: sparm ?? self.sparm, + tocsin: tocsin ?? self.tocsin, + unnicked: unnicked ?? self.unnicked, + unstavable: unstavable ?? self.unstavable, + windfirm: windfirm ?? self.windfirm + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable, Sendable { + case bool(Bool) + case diaereseClass(DiaereseClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiaereseClass.self) { + self = .diaereseClass(x) + return + } + throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .diaereseClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiaereseClass +struct DiaereseClass: Codable, Sendable { + let amoreuxia: JSONNull? + let ani: JSONNull? + let bernicle: JSONNull? + let blackwasher: JSONNull? + let blowhard: JSONNull? + let broma: JSONNull? + let closecross: JSONNull? + let congregationalism: JSONNull? + let grayly: JSONNull? + let historically: JSONNull? + let hoast: JSONNull? + let irretentive: JSONNull? + let parcener: JSONNull? + let pedder: JSONNull? + let pseudoanatomic: JSONNull? + let rhizocarpian: JSONNull? + let samel: JSONNull? + let silker: JSONNull? + let subdentated: JSONNull? + let subobscure: JSONNull? + + enum CodingKeys: String, CodingKey { + case amoreuxia = "Amoreuxia" + case ani = "ani" + case bernicle = "bernicle" + case blackwasher = "blackwasher" + case blowhard = "blowhard" + case broma = "broma" + case closecross = "closecross" + case congregationalism = "congregationalism" + case grayly = "grayly" + case historically = "historically" + case hoast = "hoast" + case irretentive = "irretentive" + case parcener = "parcener" + case pedder = "pedder" + case pseudoanatomic = "pseudoanatomic" + case rhizocarpian = "rhizocarpian" + case samel = "samel" + case silker = "silker" + case subdentated = "subdentated" + case subobscure = "subobscure" + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(DiaereseClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amoreuxia: JSONNull?? = nil, + ani: JSONNull?? = nil, + bernicle: JSONNull?? = nil, + blackwasher: JSONNull?? = nil, + blowhard: JSONNull?? = nil, + broma: JSONNull?? = nil, + closecross: JSONNull?? = nil, + congregationalism: JSONNull?? = nil, + grayly: JSONNull?? = nil, + historically: JSONNull?? = nil, + hoast: JSONNull?? = nil, + irretentive: JSONNull?? = nil, + parcener: JSONNull?? = nil, + pedder: JSONNull?? = nil, + pseudoanatomic: JSONNull?? = nil, + rhizocarpian: JSONNull?? = nil, + samel: JSONNull?? = nil, + silker: JSONNull?? = nil, + subdentated: JSONNull?? = nil, + subobscure: JSONNull?? = nil + ) -> DiaereseClass { + return DiaereseClass( + amoreuxia: amoreuxia ?? self.amoreuxia, + ani: ani ?? self.ani, + bernicle: bernicle ?? self.bernicle, + blackwasher: blackwasher ?? self.blackwasher, + blowhard: blowhard ?? self.blowhard, + broma: broma ?? self.broma, + closecross: closecross ?? self.closecross, + congregationalism: congregationalism ?? self.congregationalism, + grayly: grayly ?? self.grayly, + historically: historically ?? self.historically, + hoast: hoast ?? self.hoast, + irretentive: irretentive ?? self.irretentive, + parcener: parcener ?? self.parcener, + pedder: pedder ?? self.pedder, + pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic, + rhizocarpian: rhizocarpian ?? self.rhizocarpian, + samel: samel ?? self.samel, + silker: silker ?? self.silker, + subdentated: subdentated ?? self.subdentated, + subobscure: subobscure ?? self.subobscure + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Downstroke: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eleutheromania: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Encrust +struct Encrust: Codable, Sendable { + let comradely: JSONNull? + let diacanthous: JSONNull? + let feminineness: JSONNull? + let gossamered: JSONNull? + let hibernia: JSONNull? + let hibiscus: JSONNull? + let lepidosauria: JSONNull? + let lollingly: JSONNull? + let manager: JSONNull? + let mechanic: JSONNull? + let overminuteness: JSONNull? + let papelonne: JSONNull? + let plebification: JSONNull? + let pugmiller: JSONNull? + let recoveror: JSONNull? + let spermatoblastic: JSONNull? + let syllidae: JSONNull? + let ungyved: JSONNull? + let whirlabout: JSONNull? + let woodenware: JSONNull? + + enum CodingKeys: String, CodingKey { + case comradely = "comradely" + case diacanthous = "diacanthous" + case feminineness = "feminineness" + case gossamered = "gossamered" + case hibernia = "Hibernia" + case hibiscus = "Hibiscus" + case lepidosauria = "Lepidosauria" + case lollingly = "lollingly" + case manager = "manager" + case mechanic = "mechanic" + case overminuteness = "overminuteness" + case papelonne = "papelonne" + case plebification = "plebification" + case pugmiller = "pugmiller" + case recoveror = "recoveror" + case spermatoblastic = "spermatoblastic" + case syllidae = "Syllidae" + case ungyved = "ungyved" + case whirlabout = "whirlabout" + case woodenware = "woodenware" + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + init(data: Data) throws { + self = try newJSONDecoder().decode(Encrust.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + comradely: JSONNull?? = nil, + diacanthous: JSONNull?? = nil, + feminineness: JSONNull?? = nil, + gossamered: JSONNull?? = nil, + hibernia: JSONNull?? = nil, + hibiscus: JSONNull?? = nil, + lepidosauria: JSONNull?? = nil, + lollingly: JSONNull?? = nil, + manager: JSONNull?? = nil, + mechanic: JSONNull?? = nil, + overminuteness: JSONNull?? = nil, + papelonne: JSONNull?? = nil, + plebification: JSONNull?? = nil, + pugmiller: JSONNull?? = nil, + recoveror: JSONNull?? = nil, + spermatoblastic: JSONNull?? = nil, + syllidae: JSONNull?? = nil, + ungyved: JSONNull?? = nil, + whirlabout: JSONNull?? = nil, + woodenware: JSONNull?? = nil + ) -> Encrust { + return Encrust( + comradely: comradely ?? self.comradely, + diacanthous: diacanthous ?? self.diacanthous, + feminineness: feminineness ?? self.feminineness, + gossamered: gossamered ?? self.gossamered, + hibernia: hibernia ?? self.hibernia, + hibiscus: hibiscus ?? self.hibiscus, + lepidosauria: lepidosauria ?? self.lepidosauria, + lollingly: lollingly ?? self.lollingly, + manager: manager ?? self.manager, + mechanic: mechanic ?? self.mechanic, + overminuteness: overminuteness ?? self.overminuteness, + papelonne: papelonne ?? self.papelonne, + plebification: plebification ?? self.plebification, + pugmiller: pugmiller ?? self.pugmiller, + recoveror: recoveror ?? self.recoveror, + spermatoblastic: spermatoblastic ?? self.spermatoblastic, + syllidae: syllidae ?? self.syllidae, + ungyved: ungyved ?? self.ungyved, + whirlabout: whirlabout ?? self.whirlabout, + woodenware: woodenware ?? self.woodenware + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Epipaleolithic: Codable, Sendable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Expropriable: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum FagginglyElement: Codable, Sendable { + case double(Double) + case fagginglyClass(FagginglyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FagginglyClass.self) { + self = .fagginglyClass(x) + return + } + throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .fagginglyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FagginglyClass +struct FagginglyClass: Codable, Sendable { + let abranchian: JSONNull? + let aculeiform: JSONNull? + let adiaphoristic: JSONNull? + let adoptionism: JSONNull? + let anglic: JSONNull? + let antrotomy: JSONNull? + let coerciveness: JSONNull? + let decorist: JSONNull? + let duckhood: JSONNull? + let heteromeri: JSONNull? + let hypochnose: JSONNull? + let lochage: JSONNull? + let melee: JSONNull? + let nonconformitant: JSONNull? + let poinsettia: JSONNull? + let putatively: JSONNull? + let semivolatile: JSONNull? + let soleas: JSONNull? + let unfastenable: JSONNull? + let unmillinered: JSONNull? + + enum CodingKeys: String, CodingKey { + case abranchian = "abranchian" + case aculeiform = "aculeiform" + case adiaphoristic = "adiaphoristic" + case adoptionism = "adoptionism" + case anglic = "Anglic" + case antrotomy = "antrotomy" + case coerciveness = "coerciveness" + case decorist = "decorist" + case duckhood = "duckhood" + case heteromeri = "Heteromeri" + case hypochnose = "hypochnose" + case lochage = "lochage" + case melee = "melee" + case nonconformitant = "nonconformitant" + case poinsettia = "Poinsettia" + case putatively = "putatively" + case semivolatile = "semivolatile" + case soleas = "soleas" + case unfastenable = "unfastenable" + case unmillinered = "unmillinered" + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(FagginglyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchian: JSONNull?? = nil, + aculeiform: JSONNull?? = nil, + adiaphoristic: JSONNull?? = nil, + adoptionism: JSONNull?? = nil, + anglic: JSONNull?? = nil, + antrotomy: JSONNull?? = nil, + coerciveness: JSONNull?? = nil, + decorist: JSONNull?? = nil, + duckhood: JSONNull?? = nil, + heteromeri: JSONNull?? = nil, + hypochnose: JSONNull?? = nil, + lochage: JSONNull?? = nil, + melee: JSONNull?? = nil, + nonconformitant: JSONNull?? = nil, + poinsettia: JSONNull?? = nil, + putatively: JSONNull?? = nil, + semivolatile: JSONNull?? = nil, + soleas: JSONNull?? = nil, + unfastenable: JSONNull?? = nil, + unmillinered: JSONNull?? = nil + ) -> FagginglyClass { + return FagginglyClass( + abranchian: abranchian ?? self.abranchian, + aculeiform: aculeiform ?? self.aculeiform, + adiaphoristic: adiaphoristic ?? self.adiaphoristic, + adoptionism: adoptionism ?? self.adoptionism, + anglic: anglic ?? self.anglic, + antrotomy: antrotomy ?? self.antrotomy, + coerciveness: coerciveness ?? self.coerciveness, + decorist: decorist ?? self.decorist, + duckhood: duckhood ?? self.duckhood, + heteromeri: heteromeri ?? self.heteromeri, + hypochnose: hypochnose ?? self.hypochnose, + lochage: lochage ?? self.lochage, + melee: melee ?? self.melee, + nonconformitant: nonconformitant ?? self.nonconformitant, + poinsettia: poinsettia ?? self.poinsettia, + putatively: putatively ?? self.putatively, + semivolatile: semivolatile ?? self.semivolatile, + soleas: soleas ?? self.soleas, + unfastenable: unfastenable ?? self.unfastenable, + unmillinered: unmillinered ?? self.unmillinered + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable, Sendable { + case fenkClass(FenkClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(FenkClass.self) { + self = .fenkClass(x) + return + } + throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .fenkClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - FenkClass +struct FenkClass: Codable, Sendable { + let apoise: JSONNull? + let astronomize: JSONNull? + let cockhorse: JSONNull? + let copular: JSONNull? + let dagomba: JSONNull? + let draffy: JSONNull? + let foreigner: JSONNull? + let guyandot: JSONNull? + let neurogliosis: JSONNull? + let osmious: JSONNull? + let palpitate: JSONNull? + let rebukeable: JSONNull? + let reinwardtia: JSONNull? + let reservatory: JSONNull? + let scalt: JSONNull? + let scripturalize: JSONNull? + let tintometer: JSONNull? + let tritoness: JSONNull? + let undergrade: JSONNull? + let undermountain: JSONNull? + + enum CodingKeys: String, CodingKey { + case apoise = "apoise" + case astronomize = "astronomize" + case cockhorse = "cockhorse" + case copular = "copular" + case dagomba = "Dagomba" + case draffy = "draffy" + case foreigner = "foreigner" + case guyandot = "Guyandot" + case neurogliosis = "neurogliosis" + case osmious = "osmious" + case palpitate = "palpitate" + case rebukeable = "rebukeable" + case reinwardtia = "Reinwardtia" + case reservatory = "reservatory" + case scalt = "scalt" + case scripturalize = "scripturalize" + case tintometer = "tintometer" + case tritoness = "Tritoness" + case undergrade = "undergrade" + case undermountain = "undermountain" + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(FenkClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apoise: JSONNull?? = nil, + astronomize: JSONNull?? = nil, + cockhorse: JSONNull?? = nil, + copular: JSONNull?? = nil, + dagomba: JSONNull?? = nil, + draffy: JSONNull?? = nil, + foreigner: JSONNull?? = nil, + guyandot: JSONNull?? = nil, + neurogliosis: JSONNull?? = nil, + osmious: JSONNull?? = nil, + palpitate: JSONNull?? = nil, + rebukeable: JSONNull?? = nil, + reinwardtia: JSONNull?? = nil, + reservatory: JSONNull?? = nil, + scalt: JSONNull?? = nil, + scripturalize: JSONNull?? = nil, + tintometer: JSONNull?? = nil, + tritoness: JSONNull?? = nil, + undergrade: JSONNull?? = nil, + undermountain: JSONNull?? = nil + ) -> FenkClass { + return FenkClass( + apoise: apoise ?? self.apoise, + astronomize: astronomize ?? self.astronomize, + cockhorse: cockhorse ?? self.cockhorse, + copular: copular ?? self.copular, + dagomba: dagomba ?? self.dagomba, + draffy: draffy ?? self.draffy, + foreigner: foreigner ?? self.foreigner, + guyandot: guyandot ?? self.guyandot, + neurogliosis: neurogliosis ?? self.neurogliosis, + osmious: osmious ?? self.osmious, + palpitate: palpitate ?? self.palpitate, + rebukeable: rebukeable ?? self.rebukeable, + reinwardtia: reinwardtia ?? self.reinwardtia, + reservatory: reservatory ?? self.reservatory, + scalt: scalt ?? self.scalt, + scripturalize: scripturalize ?? self.scripturalize, + tintometer: tintometer ?? self.tintometer, + tritoness: tritoness ?? self.tritoness, + undergrade: undergrade ?? self.undergrade, + undermountain: undermountain ?? self.undermountain + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable, Sendable { + case bool(Bool) + case double(Double) + case flagmakingClass(FlagmakingClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FlagmakingClass.self) { + self = .flagmakingClass(x) + return + } + throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .flagmakingClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FlagmakingClass +struct FlagmakingClass: Codable, Sendable { + let albarco: JSONNull? + let bunodonta: JSONNull? + let hornify: JSONNull? + let hydrocorisae: JSONNull? + let hypoglossus: JSONNull? + let inexpiably: JSONNull? + let ingratitude: JSONNull? + let ladyfly: JSONNull? + let medicament: JSONNull? + let monogrammatic: JSONNull? + let nobbut: JSONNull? + let notacanthidae: JSONNull? + let polyplacophore: JSONNull? + let proexercise: JSONNull? + let protoplast: JSONNull? + let puzzling: JSONNull? + let splanchnoskeleton: JSONNull? + let unloveliness: JSONNull? + let unquarantined: JSONNull? + let unrenounceable: JSONNull? + + enum CodingKeys: String, CodingKey { + case albarco = "albarco" + case bunodonta = "Bunodonta" + case hornify = "hornify" + case hydrocorisae = "Hydrocorisae" + case hypoglossus = "hypoglossus" + case inexpiably = "inexpiably" + case ingratitude = "ingratitude" + case ladyfly = "ladyfly" + case medicament = "medicament" + case monogrammatic = "monogrammatic" + case nobbut = "nobbut" + case notacanthidae = "Notacanthidae" + case polyplacophore = "polyplacophore" + case proexercise = "proexercise" + case protoplast = "protoplast" + case puzzling = "puzzling" + case splanchnoskeleton = "splanchnoskeleton" + case unloveliness = "unloveliness" + case unquarantined = "unquarantined" + case unrenounceable = "unrenounceable" + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(FlagmakingClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + albarco: JSONNull?? = nil, + bunodonta: JSONNull?? = nil, + hornify: JSONNull?? = nil, + hydrocorisae: JSONNull?? = nil, + hypoglossus: JSONNull?? = nil, + inexpiably: JSONNull?? = nil, + ingratitude: JSONNull?? = nil, + ladyfly: JSONNull?? = nil, + medicament: JSONNull?? = nil, + monogrammatic: JSONNull?? = nil, + nobbut: JSONNull?? = nil, + notacanthidae: JSONNull?? = nil, + polyplacophore: JSONNull?? = nil, + proexercise: JSONNull?? = nil, + protoplast: JSONNull?? = nil, + puzzling: JSONNull?? = nil, + splanchnoskeleton: JSONNull?? = nil, + unloveliness: JSONNull?? = nil, + unquarantined: JSONNull?? = nil, + unrenounceable: JSONNull?? = nil + ) -> FlagmakingClass { + return FlagmakingClass( + albarco: albarco ?? self.albarco, + bunodonta: bunodonta ?? self.bunodonta, + hornify: hornify ?? self.hornify, + hydrocorisae: hydrocorisae ?? self.hydrocorisae, + hypoglossus: hypoglossus ?? self.hypoglossus, + inexpiably: inexpiably ?? self.inexpiably, + ingratitude: ingratitude ?? self.ingratitude, + ladyfly: ladyfly ?? self.ladyfly, + medicament: medicament ?? self.medicament, + monogrammatic: monogrammatic ?? self.monogrammatic, + nobbut: nobbut ?? self.nobbut, + notacanthidae: notacanthidae ?? self.notacanthidae, + polyplacophore: polyplacophore ?? self.polyplacophore, + proexercise: proexercise ?? self.proexercise, + protoplast: protoplast ?? self.protoplast, + puzzling: puzzling ?? self.puzzling, + splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton, + unloveliness: unloveliness ?? self.unloveliness, + unquarantined: unquarantined ?? self.unquarantined, + unrenounceable: unrenounceable ?? self.unrenounceable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Fluorometer: Codable, Sendable { + case integer(Int) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Fuzzy: Codable, Sendable { + case integer(Int) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Gardenward: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Generalissimo: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hemicrystalline: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum HemocoeleElement: Codable, Sendable { + case hemocoeleClass(HemocoeleClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(HemocoeleClass.self) { + self = .hemocoeleClass(x) + return + } + throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .hemocoeleClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - HemocoeleClass +struct HemocoeleClass: Codable, Sendable { + let acrogamy: JSONNull? + let amelification: JSONNull? + let autobiographic: JSONNull? + let berat: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let disproportionably: JSONNull? + let erythrite: JSONNull? + let graphic: JSONNull? + let hepatological: JSONNull? + let homocerc: Bool? + let incommensurably: JSONNull? + let misaffirm: JSONNull? + let nonbookish: JSONNull? + let pocketbook: JSONNull? + let sclerometric: JSONNull? + let stambouline: JSONNull? + let stickpin: JSONNull? + let tubulure: JSONNull? + let undelated: JSONNull? + let unsalt: JSONNull? + let untutelar: JSONNull? + let vagrant: JSONNull? + let walt: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrogamy = "acrogamy" + case amelification = "amelification" + case autobiographic = "autobiographic" + case berat = "berat" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case disproportionably = "disproportionably" + case erythrite = "erythrite" + case graphic = "graphic" + case hepatological = "hepatological" + case homocerc = "homocerc" + case incommensurably = "incommensurably" + case misaffirm = "misaffirm" + case nonbookish = "nonbookish" + case pocketbook = "pocketbook" + case sclerometric = "sclerometric" + case stambouline = "stambouline" + case stickpin = "stickpin" + case tubulure = "tubulure" + case undelated = "undelated" + case unsalt = "unsalt" + case untutelar = "untutelar" + case vagrant = "vagrant" + case walt = "Walt" + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(HemocoeleClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrogamy: JSONNull?? = nil, + amelification: JSONNull?? = nil, + autobiographic: JSONNull?? = nil, + berat: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + disproportionably: JSONNull?? = nil, + erythrite: JSONNull?? = nil, + graphic: JSONNull?? = nil, + hepatological: JSONNull?? = nil, + homocerc: Bool?? = nil, + incommensurably: JSONNull?? = nil, + misaffirm: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + pocketbook: JSONNull?? = nil, + sclerometric: JSONNull?? = nil, + stambouline: JSONNull?? = nil, + stickpin: JSONNull?? = nil, + tubulure: JSONNull?? = nil, + undelated: JSONNull?? = nil, + unsalt: JSONNull?? = nil, + untutelar: JSONNull?? = nil, + vagrant: JSONNull?? = nil, + walt: JSONNull?? = nil + ) -> HemocoeleClass { + return HemocoeleClass( + acrogamy: acrogamy ?? self.acrogamy, + amelification: amelification ?? self.amelification, + autobiographic: autobiographic ?? self.autobiographic, + berat: berat ?? self.berat, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + disproportionably: disproportionably ?? self.disproportionably, + erythrite: erythrite ?? self.erythrite, + graphic: graphic ?? self.graphic, + hepatological: hepatological ?? self.hepatological, + homocerc: homocerc ?? self.homocerc, + incommensurably: incommensurably ?? self.incommensurably, + misaffirm: misaffirm ?? self.misaffirm, + nonbookish: nonbookish ?? self.nonbookish, + pocketbook: pocketbook ?? self.pocketbook, + sclerometric: sclerometric ?? self.sclerometric, + stambouline: stambouline ?? self.stambouline, + stickpin: stickpin ?? self.stickpin, + tubulure: tubulure ?? self.tubulure, + undelated: undelated ?? self.undelated, + unsalt: unsalt ?? self.unsalt, + untutelar: untutelar ?? self.untutelar, + vagrant: vagrant ?? self.vagrant, + walt: walt ?? self.walt + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyperpiesi: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyppish: Codable, Sendable { + case bool(Bool) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Idealizer: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Incrustator: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Intentiveness: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Interacinar +struct Interacinar: Codable, Sendable { + let assapan: Double + let benefactorship: Bool + let triseriatim: String + let tubbing: Int + let untrimmed: JSONNull? + + enum CodingKeys: String, CodingKey { + case assapan = "assapan" + case benefactorship = "benefactorship" + case triseriatim = "triseriatim" + case tubbing = "tubbing" + case untrimmed = "untrimmed" + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + init(data: Data) throws { + self = try newJSONDecoder().decode(Interacinar.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + assapan: Double? = nil, + benefactorship: Bool? = nil, + triseriatim: String? = nil, + tubbing: Int? = nil, + untrimmed: JSONNull?? = nil + ) -> Interacinar { + return Interacinar( + assapan: assapan ?? self.assapan, + benefactorship: benefactorship ?? self.benefactorship, + triseriatim: triseriatim ?? self.triseriatim, + tubbing: tubbing ?? self.tubbing, + untrimmed: untrimmed ?? self.untrimmed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Jacutinga: Codable, Sendable { + case integerArray([Int]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations1.json/struct-or-class-class--238d6c8a12d4/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations1.json/struct-or-class-class--238d6c8a12d4/quicktype.swift new file mode 100644 index 0000000..0c93bd0 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations1.json/struct-or-class-class--238d6c8a12d4/quicktype.swift @@ -0,0 +1,3182 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable, Sendable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [Jacutinga] + + enum CodingKeys: String, CodingKey { + case centrodesmose = "centrodesmose" + case cerograph = "cerograph" + case chemotherapeutics = "chemotherapeutics" + case cimelia = "cimelia" + case citrated = "citrated" + case clinodome = "clinodome" + case coadjust = "coadjust" + case consilience = "consilience" + case constructor = "constructor" + case continuative = "continuative" + case credulity = "credulity" + case creviced = "creviced" + case cubiculum = "cubiculum" + case deruralize = "deruralize" + case diaereses = "diaereses" + case dissolution = "dissolution" + case downstroke = "downstroke" + case electrotautomerism = "electrotautomerism" + case eleutheromania = "eleutheromania" + case encrust = "encrust" + case entomoid = "entomoid" + case epipaleolithic = "epipaleolithic" + case expropriable = "expropriable" + case faggingly = "faggingly" + case fenks = "fenks" + case flagmaking = "flagmaking" + case fluorometer = "fluorometer" + case fulsome = "fulsome" + case fuzzy = "fuzzy" + case gardenwards = "gardenwards" + case generalissimo = "generalissimo" + case habeas = "habeas" + case hemicrystalline = "hemicrystalline" + case hemocoele = "hemocoele" + case hoister = "hoister" + case hyperpiesis = "hyperpiesis" + case hyppish = "hyppish" + case idealizer = "idealizer" + case incrustator = "incrustator" + case intentiveness = "intentiveness" + case interacinar = "interacinar" + case intercorrelation = "intercorrelation" + case jacutinga = "jacutinga" + } + + init(centrodesmose: String, cerograph: [CerographElement], chemotherapeutics: [ChemotherapeuticElement], cimelia: [CimeliaElement], citrated: Int, clinodome: [Clinodome], coadjust: [CoadjustElement], consilience: [Consilience], constructor: [Constructor], continuative: [Continuative], credulity: [CredulityElement], creviced: [Creviced], cubiculum: [[Int?]], deruralize: [DeruralizeElement], diaereses: [DiaereseElement], dissolution: [[JSONNull?]?], downstroke: [Downstroke], electrotautomerism: [Double?], eleutheromania: [Eleutheromania], encrust: Encrust, entomoid: [Entomoid], epipaleolithic: [Epipaleolithic], expropriable: [Expropriable], faggingly: [FagginglyElement], fenks: [FenkElement], flagmaking: [FlagmakingElement], fluorometer: [Fluorometer], fulsome: [Int?], fuzzy: [Fuzzy], gardenwards: [Gardenward], generalissimo: [Generalissimo], habeas: [[String: Int]?], hemicrystalline: [Hemicrystalline], hemocoele: [HemocoeleElement], hoister: [Hoister], hyperpiesis: [Hyperpiesi], hyppish: [Hyppish], idealizer: [Idealizer], incrustator: [Incrustator], intentiveness: [Intentiveness], interacinar: Interacinar, intercorrelation: [[Int]?], jacutinga: [Jacutinga]) { + self.centrodesmose = centrodesmose + self.cerograph = cerograph + self.chemotherapeutics = chemotherapeutics + self.cimelia = cimelia + self.citrated = citrated + self.clinodome = clinodome + self.coadjust = coadjust + self.consilience = consilience + self.constructor = constructor + self.continuative = continuative + self.credulity = credulity + self.creviced = creviced + self.cubiculum = cubiculum + self.deruralize = deruralize + self.diaereses = diaereses + self.dissolution = dissolution + self.downstroke = downstroke + self.electrotautomerism = electrotautomerism + self.eleutheromania = eleutheromania + self.encrust = encrust + self.entomoid = entomoid + self.epipaleolithic = epipaleolithic + self.expropriable = expropriable + self.faggingly = faggingly + self.fenks = fenks + self.flagmaking = flagmaking + self.fluorometer = fluorometer + self.fulsome = fulsome + self.fuzzy = fuzzy + self.gardenwards = gardenwards + self.generalissimo = generalissimo + self.habeas = habeas + self.hemicrystalline = hemicrystalline + self.hemocoele = hemocoele + self.hoister = hoister + self.hyperpiesis = hyperpiesis + self.hyppish = hyppish + self.idealizer = idealizer + self.incrustator = incrustator + self.intentiveness = intentiveness + self.interacinar = interacinar + self.intercorrelation = intercorrelation + self.jacutinga = jacutinga + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(centrodesmose: me.centrodesmose, cerograph: me.cerograph, chemotherapeutics: me.chemotherapeutics, cimelia: me.cimelia, citrated: me.citrated, clinodome: me.clinodome, coadjust: me.coadjust, consilience: me.consilience, constructor: me.constructor, continuative: me.continuative, credulity: me.credulity, creviced: me.creviced, cubiculum: me.cubiculum, deruralize: me.deruralize, diaereses: me.diaereses, dissolution: me.dissolution, downstroke: me.downstroke, electrotautomerism: me.electrotautomerism, eleutheromania: me.eleutheromania, encrust: me.encrust, entomoid: me.entomoid, epipaleolithic: me.epipaleolithic, expropriable: me.expropriable, faggingly: me.faggingly, fenks: me.fenks, flagmaking: me.flagmaking, fluorometer: me.fluorometer, fulsome: me.fulsome, fuzzy: me.fuzzy, gardenwards: me.gardenwards, generalissimo: me.generalissimo, habeas: me.habeas, hemicrystalline: me.hemicrystalline, hemocoele: me.hemocoele, hoister: me.hoister, hyperpiesis: me.hyperpiesis, hyppish: me.hyppish, idealizer: me.idealizer, incrustator: me.incrustator, intentiveness: me.intentiveness, interacinar: me.interacinar, intercorrelation: me.intercorrelation, jacutinga: me.jacutinga) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [Jacutinga]? = nil + ) -> TopLevel { + return TopLevel( + centrodesmose: centrodesmose ?? self.centrodesmose, + cerograph: cerograph ?? self.cerograph, + chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics, + cimelia: cimelia ?? self.cimelia, + citrated: citrated ?? self.citrated, + clinodome: clinodome ?? self.clinodome, + coadjust: coadjust ?? self.coadjust, + consilience: consilience ?? self.consilience, + constructor: constructor ?? self.constructor, + continuative: continuative ?? self.continuative, + credulity: credulity ?? self.credulity, + creviced: creviced ?? self.creviced, + cubiculum: cubiculum ?? self.cubiculum, + deruralize: deruralize ?? self.deruralize, + diaereses: diaereses ?? self.diaereses, + dissolution: dissolution ?? self.dissolution, + downstroke: downstroke ?? self.downstroke, + electrotautomerism: electrotautomerism ?? self.electrotautomerism, + eleutheromania: eleutheromania ?? self.eleutheromania, + encrust: encrust ?? self.encrust, + entomoid: entomoid ?? self.entomoid, + epipaleolithic: epipaleolithic ?? self.epipaleolithic, + expropriable: expropriable ?? self.expropriable, + faggingly: faggingly ?? self.faggingly, + fenks: fenks ?? self.fenks, + flagmaking: flagmaking ?? self.flagmaking, + fluorometer: fluorometer ?? self.fluorometer, + fulsome: fulsome ?? self.fulsome, + fuzzy: fuzzy ?? self.fuzzy, + gardenwards: gardenwards ?? self.gardenwards, + generalissimo: generalissimo ?? self.generalissimo, + habeas: habeas ?? self.habeas, + hemicrystalline: hemicrystalline ?? self.hemicrystalline, + hemocoele: hemocoele ?? self.hemocoele, + hoister: hoister ?? self.hoister, + hyperpiesis: hyperpiesis ?? self.hyperpiesis, + hyppish: hyppish ?? self.hyppish, + idealizer: idealizer ?? self.idealizer, + incrustator: incrustator ?? self.incrustator, + intentiveness: intentiveness ?? self.intentiveness, + interacinar: interacinar ?? self.interacinar, + intercorrelation: intercorrelation ?? self.intercorrelation, + jacutinga: jacutinga ?? self.jacutinga + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable, Sendable { + case cerographClass(CerographClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CerographClass.self) { + self = .cerographClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cerographClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CerographClass +final class CerographClass: Codable, Sendable { + let apotropaion: JSONNull? + let casuary: JSONNull? + let creaker: JSONNull? + let disqualification: JSONNull? + let imperatorious: JSONNull? + let impermeabilize: JSONNull? + let metastoma: JSONNull? + let noctidiurnal: JSONNull? + let nonreserve: JSONNull? + let ophthalmotonometry: JSONNull? + let pailful: JSONNull? + let pigfish: JSONNull? + let pongee: JSONNull? + let prosodical: JSONNull? + let scrofuloderm: JSONNull? + let storekeeping: JSONNull? + let therologist: JSONNull? + let tolowa: JSONNull? + let tradeful: JSONNull? + let unriveting: JSONNull? + + enum CodingKeys: String, CodingKey { + case apotropaion = "apotropaion" + case casuary = "casuary" + case creaker = "creaker" + case disqualification = "disqualification" + case imperatorious = "imperatorious" + case impermeabilize = "impermeabilize" + case metastoma = "metastoma" + case noctidiurnal = "noctidiurnal" + case nonreserve = "nonreserve" + case ophthalmotonometry = "ophthalmotonometry" + case pailful = "pailful" + case pigfish = "pigfish" + case pongee = "pongee" + case prosodical = "prosodical" + case scrofuloderm = "scrofuloderm" + case storekeeping = "storekeeping" + case therologist = "therologist" + case tolowa = "Tolowa" + case tradeful = "tradeful" + case unriveting = "unriveting" + } + + init(apotropaion: JSONNull?, casuary: JSONNull?, creaker: JSONNull?, disqualification: JSONNull?, imperatorious: JSONNull?, impermeabilize: JSONNull?, metastoma: JSONNull?, noctidiurnal: JSONNull?, nonreserve: JSONNull?, ophthalmotonometry: JSONNull?, pailful: JSONNull?, pigfish: JSONNull?, pongee: JSONNull?, prosodical: JSONNull?, scrofuloderm: JSONNull?, storekeeping: JSONNull?, therologist: JSONNull?, tolowa: JSONNull?, tradeful: JSONNull?, unriveting: JSONNull?) { + self.apotropaion = apotropaion + self.casuary = casuary + self.creaker = creaker + self.disqualification = disqualification + self.imperatorious = imperatorious + self.impermeabilize = impermeabilize + self.metastoma = metastoma + self.noctidiurnal = noctidiurnal + self.nonreserve = nonreserve + self.ophthalmotonometry = ophthalmotonometry + self.pailful = pailful + self.pigfish = pigfish + self.pongee = pongee + self.prosodical = prosodical + self.scrofuloderm = scrofuloderm + self.storekeeping = storekeeping + self.therologist = therologist + self.tolowa = tolowa + self.tradeful = tradeful + self.unriveting = unriveting + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CerographClass.self, from: data) + self.init(apotropaion: me.apotropaion, casuary: me.casuary, creaker: me.creaker, disqualification: me.disqualification, imperatorious: me.imperatorious, impermeabilize: me.impermeabilize, metastoma: me.metastoma, noctidiurnal: me.noctidiurnal, nonreserve: me.nonreserve, ophthalmotonometry: me.ophthalmotonometry, pailful: me.pailful, pigfish: me.pigfish, pongee: me.pongee, prosodical: me.prosodical, scrofuloderm: me.scrofuloderm, storekeeping: me.storekeeping, therologist: me.therologist, tolowa: me.tolowa, tradeful: me.tradeful, unriveting: me.unriveting) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apotropaion: JSONNull?? = nil, + casuary: JSONNull?? = nil, + creaker: JSONNull?? = nil, + disqualification: JSONNull?? = nil, + imperatorious: JSONNull?? = nil, + impermeabilize: JSONNull?? = nil, + metastoma: JSONNull?? = nil, + noctidiurnal: JSONNull?? = nil, + nonreserve: JSONNull?? = nil, + ophthalmotonometry: JSONNull?? = nil, + pailful: JSONNull?? = nil, + pigfish: JSONNull?? = nil, + pongee: JSONNull?? = nil, + prosodical: JSONNull?? = nil, + scrofuloderm: JSONNull?? = nil, + storekeeping: JSONNull?? = nil, + therologist: JSONNull?? = nil, + tolowa: JSONNull?? = nil, + tradeful: JSONNull?? = nil, + unriveting: JSONNull?? = nil + ) -> CerographClass { + return CerographClass( + apotropaion: apotropaion ?? self.apotropaion, + casuary: casuary ?? self.casuary, + creaker: creaker ?? self.creaker, + disqualification: disqualification ?? self.disqualification, + imperatorious: imperatorious ?? self.imperatorious, + impermeabilize: impermeabilize ?? self.impermeabilize, + metastoma: metastoma ?? self.metastoma, + noctidiurnal: noctidiurnal ?? self.noctidiurnal, + nonreserve: nonreserve ?? self.nonreserve, + ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry, + pailful: pailful ?? self.pailful, + pigfish: pigfish ?? self.pigfish, + pongee: pongee ?? self.pongee, + prosodical: prosodical ?? self.prosodical, + scrofuloderm: scrofuloderm ?? self.scrofuloderm, + storekeeping: storekeeping ?? self.storekeeping, + therologist: therologist ?? self.therologist, + tolowa: tolowa ?? self.tolowa, + tradeful: tradeful ?? self.tradeful, + unriveting: unriveting ?? self.unriveting + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable, Sendable { + case chemotherapeuticClass(ChemotherapeuticClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(ChemotherapeuticClass.self) { + self = .chemotherapeuticClass(x) + return + } + throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .chemotherapeuticClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +// MARK: - ChemotherapeuticClass +final class ChemotherapeuticClass: Codable, Sendable { + let angioneurotic: JSONNull? + let availment: JSONNull? + let bladelet: JSONNull? + let catharticalness: Double? + let caulis: JSONNull? + let chalcus: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let enteradenological: JSONNull? + let homocerc: Bool? + let imporosity: JSONNull? + let insistently: JSONNull? + let intraparietal: JSONNull? + let ivied: JSONNull? + let maureen: JSONNull? + let nonbookish: JSONNull? + let nostochine: JSONNull? + let nutcracker: JSONNull? + let ofttimes: JSONNull? + let phenocryst: JSONNull? + let precoincident: JSONNull? + let ramiferous: JSONNull? + let stagmometer: JSONNull? + let tetherball: JSONNull? + let unshy: JSONNull? + + enum CodingKeys: String, CodingKey { + case angioneurotic = "angioneurotic" + case availment = "availment" + case bladelet = "bladelet" + case catharticalness = "catharticalness" + case caulis = "caulis" + case chalcus = "chalcus" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case enteradenological = "enteradenological" + case homocerc = "homocerc" + case imporosity = "imporosity" + case insistently = "insistently" + case intraparietal = "intraparietal" + case ivied = "ivied" + case maureen = "Maureen" + case nonbookish = "nonbookish" + case nostochine = "nostochine" + case nutcracker = "nutcracker" + case ofttimes = "ofttimes" + case phenocryst = "phenocryst" + case precoincident = "precoincident" + case ramiferous = "ramiferous" + case stagmometer = "stagmometer" + case tetherball = "tetherball" + case unshy = "unshy" + } + + init(angioneurotic: JSONNull?, availment: JSONNull?, bladelet: JSONNull?, catharticalness: Double?, caulis: JSONNull?, chalcus: JSONNull?, chirotherium: Int?, disdiapason: String?, enteradenological: JSONNull?, homocerc: Bool?, imporosity: JSONNull?, insistently: JSONNull?, intraparietal: JSONNull?, ivied: JSONNull?, maureen: JSONNull?, nonbookish: JSONNull?, nostochine: JSONNull?, nutcracker: JSONNull?, ofttimes: JSONNull?, phenocryst: JSONNull?, precoincident: JSONNull?, ramiferous: JSONNull?, stagmometer: JSONNull?, tetherball: JSONNull?, unshy: JSONNull?) { + self.angioneurotic = angioneurotic + self.availment = availment + self.bladelet = bladelet + self.catharticalness = catharticalness + self.caulis = caulis + self.chalcus = chalcus + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.enteradenological = enteradenological + self.homocerc = homocerc + self.imporosity = imporosity + self.insistently = insistently + self.intraparietal = intraparietal + self.ivied = ivied + self.maureen = maureen + self.nonbookish = nonbookish + self.nostochine = nostochine + self.nutcracker = nutcracker + self.ofttimes = ofttimes + self.phenocryst = phenocryst + self.precoincident = precoincident + self.ramiferous = ramiferous + self.stagmometer = stagmometer + self.tetherball = tetherball + self.unshy = unshy + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data) + self.init(angioneurotic: me.angioneurotic, availment: me.availment, bladelet: me.bladelet, catharticalness: me.catharticalness, caulis: me.caulis, chalcus: me.chalcus, chirotherium: me.chirotherium, disdiapason: me.disdiapason, enteradenological: me.enteradenological, homocerc: me.homocerc, imporosity: me.imporosity, insistently: me.insistently, intraparietal: me.intraparietal, ivied: me.ivied, maureen: me.maureen, nonbookish: me.nonbookish, nostochine: me.nostochine, nutcracker: me.nutcracker, ofttimes: me.ofttimes, phenocryst: me.phenocryst, precoincident: me.precoincident, ramiferous: me.ramiferous, stagmometer: me.stagmometer, tetherball: me.tetherball, unshy: me.unshy) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + angioneurotic: JSONNull?? = nil, + availment: JSONNull?? = nil, + bladelet: JSONNull?? = nil, + catharticalness: Double?? = nil, + caulis: JSONNull?? = nil, + chalcus: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + enteradenological: JSONNull?? = nil, + homocerc: Bool?? = nil, + imporosity: JSONNull?? = nil, + insistently: JSONNull?? = nil, + intraparietal: JSONNull?? = nil, + ivied: JSONNull?? = nil, + maureen: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nostochine: JSONNull?? = nil, + nutcracker: JSONNull?? = nil, + ofttimes: JSONNull?? = nil, + phenocryst: JSONNull?? = nil, + precoincident: JSONNull?? = nil, + ramiferous: JSONNull?? = nil, + stagmometer: JSONNull?? = nil, + tetherball: JSONNull?? = nil, + unshy: JSONNull?? = nil + ) -> ChemotherapeuticClass { + return ChemotherapeuticClass( + angioneurotic: angioneurotic ?? self.angioneurotic, + availment: availment ?? self.availment, + bladelet: bladelet ?? self.bladelet, + catharticalness: catharticalness ?? self.catharticalness, + caulis: caulis ?? self.caulis, + chalcus: chalcus ?? self.chalcus, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + enteradenological: enteradenological ?? self.enteradenological, + homocerc: homocerc ?? self.homocerc, + imporosity: imporosity ?? self.imporosity, + insistently: insistently ?? self.insistently, + intraparietal: intraparietal ?? self.intraparietal, + ivied: ivied ?? self.ivied, + maureen: maureen ?? self.maureen, + nonbookish: nonbookish ?? self.nonbookish, + nostochine: nostochine ?? self.nostochine, + nutcracker: nutcracker ?? self.nutcracker, + ofttimes: ofttimes ?? self.ofttimes, + phenocryst: phenocryst ?? self.phenocryst, + precoincident: precoincident ?? self.precoincident, + ramiferous: ramiferous ?? self.ramiferous, + stagmometer: stagmometer ?? self.stagmometer, + tetherball: tetherball ?? self.tetherball, + unshy: unshy ?? self.unshy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CimeliaClass +final class CimeliaClass: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CimeliaClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> CimeliaClass { + return CimeliaClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Clinodome: Codable, Sendable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CoadjustElement: Codable, Sendable { + case coadjustClass(CoadjustClass) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CoadjustClass.self) { + self = .coadjustClass(x) + return + } + throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .coadjustClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +// MARK: - CoadjustClass +final class CoadjustClass: Codable, Sendable { + let amidosulphonal: JSONNull? + let benny: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ensnare: JSONNull? + let homocerc: Bool? + let hybridizer: JSONNull? + let leastwise: JSONNull? + let lof: JSONNull? + let monkhood: JSONNull? + let netherlandish: JSONNull? + let nonbookish: JSONNull? + let peonism: JSONNull? + let phonelescope: JSONNull? + let porphyrogeniture: JSONNull? + let preindemnify: JSONNull? + let rosal: JSONNull? + let scalenous: JSONNull? + let scopine: JSONNull? + let sedaceae: JSONNull? + let suberinize: JSONNull? + let symbiot: JSONNull? + let tablefellow: JSONNull? + let unchargeable: JSONNull? + + enum CodingKeys: String, CodingKey { + case amidosulphonal = "amidosulphonal" + case benny = "Benny" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ensnare = "ensnare" + case homocerc = "homocerc" + case hybridizer = "hybridizer" + case leastwise = "leastwise" + case lof = "lof" + case monkhood = "monkhood" + case netherlandish = "Netherlandish" + case nonbookish = "nonbookish" + case peonism = "peonism" + case phonelescope = "Phonelescope" + case porphyrogeniture = "porphyrogeniture" + case preindemnify = "preindemnify" + case rosal = "rosal" + case scalenous = "scalenous" + case scopine = "scopine" + case sedaceae = "Sedaceae" + case suberinize = "suberinize" + case symbiot = "symbiot" + case tablefellow = "tablefellow" + case unchargeable = "unchargeable" + } + + init(amidosulphonal: JSONNull?, benny: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ensnare: JSONNull?, homocerc: Bool?, hybridizer: JSONNull?, leastwise: JSONNull?, lof: JSONNull?, monkhood: JSONNull?, netherlandish: JSONNull?, nonbookish: JSONNull?, peonism: JSONNull?, phonelescope: JSONNull?, porphyrogeniture: JSONNull?, preindemnify: JSONNull?, rosal: JSONNull?, scalenous: JSONNull?, scopine: JSONNull?, sedaceae: JSONNull?, suberinize: JSONNull?, symbiot: JSONNull?, tablefellow: JSONNull?, unchargeable: JSONNull?) { + self.amidosulphonal = amidosulphonal + self.benny = benny + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ensnare = ensnare + self.homocerc = homocerc + self.hybridizer = hybridizer + self.leastwise = leastwise + self.lof = lof + self.monkhood = monkhood + self.netherlandish = netherlandish + self.nonbookish = nonbookish + self.peonism = peonism + self.phonelescope = phonelescope + self.porphyrogeniture = porphyrogeniture + self.preindemnify = preindemnify + self.rosal = rosal + self.scalenous = scalenous + self.scopine = scopine + self.sedaceae = sedaceae + self.suberinize = suberinize + self.symbiot = symbiot + self.tablefellow = tablefellow + self.unchargeable = unchargeable + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CoadjustClass.self, from: data) + self.init(amidosulphonal: me.amidosulphonal, benny: me.benny, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ensnare: me.ensnare, homocerc: me.homocerc, hybridizer: me.hybridizer, leastwise: me.leastwise, lof: me.lof, monkhood: me.monkhood, netherlandish: me.netherlandish, nonbookish: me.nonbookish, peonism: me.peonism, phonelescope: me.phonelescope, porphyrogeniture: me.porphyrogeniture, preindemnify: me.preindemnify, rosal: me.rosal, scalenous: me.scalenous, scopine: me.scopine, sedaceae: me.sedaceae, suberinize: me.suberinize, symbiot: me.symbiot, tablefellow: me.tablefellow, unchargeable: me.unchargeable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amidosulphonal: JSONNull?? = nil, + benny: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ensnare: JSONNull?? = nil, + homocerc: Bool?? = nil, + hybridizer: JSONNull?? = nil, + leastwise: JSONNull?? = nil, + lof: JSONNull?? = nil, + monkhood: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + peonism: JSONNull?? = nil, + phonelescope: JSONNull?? = nil, + porphyrogeniture: JSONNull?? = nil, + preindemnify: JSONNull?? = nil, + rosal: JSONNull?? = nil, + scalenous: JSONNull?? = nil, + scopine: JSONNull?? = nil, + sedaceae: JSONNull?? = nil, + suberinize: JSONNull?? = nil, + symbiot: JSONNull?? = nil, + tablefellow: JSONNull?? = nil, + unchargeable: JSONNull?? = nil + ) -> CoadjustClass { + return CoadjustClass( + amidosulphonal: amidosulphonal ?? self.amidosulphonal, + benny: benny ?? self.benny, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ensnare: ensnare ?? self.ensnare, + homocerc: homocerc ?? self.homocerc, + hybridizer: hybridizer ?? self.hybridizer, + leastwise: leastwise ?? self.leastwise, + lof: lof ?? self.lof, + monkhood: monkhood ?? self.monkhood, + netherlandish: netherlandish ?? self.netherlandish, + nonbookish: nonbookish ?? self.nonbookish, + peonism: peonism ?? self.peonism, + phonelescope: phonelescope ?? self.phonelescope, + porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture, + preindemnify: preindemnify ?? self.preindemnify, + rosal: rosal ?? self.rosal, + scalenous: scalenous ?? self.scalenous, + scopine: scopine ?? self.scopine, + sedaceae: sedaceae ?? self.sedaceae, + suberinize: suberinize ?? self.suberinize, + symbiot: symbiot ?? self.symbiot, + tablefellow: tablefellow ?? self.tablefellow, + unchargeable: unchargeable ?? self.unchargeable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Consilience: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Constructor: Codable, Sendable { + case bool(Bool) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Continuative: Codable, Sendable { + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CredulityElement: Codable, Sendable { + case credulityClass(CredulityClass) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CredulityClass.self) { + self = .credulityClass(x) + return + } + throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .credulityClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - CredulityClass +final class CredulityClass: Codable, Sendable { + let ammonolytic: JSONNull? + let bushmaster: JSONNull? + let considering: JSONNull? + let consuetudinary: JSONNull? + let embarras: JSONNull? + let fineness: JSONNull? + let flaithship: JSONNull? + let flavia: JSONNull? + let gruffly: JSONNull? + let hedychium: JSONNull? + let leadwort: JSONNull? + let overseriously: JSONNull? + let parabola: JSONNull? + let pectinatodenticulate: JSONNull? + let popean: JSONNull? + let pornocrat: JSONNull? + let quadrisect: JSONNull? + let seriality: JSONNull? + let vamphorn: JSONNull? + let wharp: JSONNull? + + enum CodingKeys: String, CodingKey { + case ammonolytic = "ammonolytic" + case bushmaster = "bushmaster" + case considering = "considering" + case consuetudinary = "consuetudinary" + case embarras = "embarras" + case fineness = "fineness" + case flaithship = "flaithship" + case flavia = "Flavia" + case gruffly = "gruffly" + case hedychium = "Hedychium" + case leadwort = "leadwort" + case overseriously = "overseriously" + case parabola = "parabola" + case pectinatodenticulate = "pectinatodenticulate" + case popean = "Popean" + case pornocrat = "pornocrat" + case quadrisect = "quadrisect" + case seriality = "seriality" + case vamphorn = "vamphorn" + case wharp = "wharp" + } + + init(ammonolytic: JSONNull?, bushmaster: JSONNull?, considering: JSONNull?, consuetudinary: JSONNull?, embarras: JSONNull?, fineness: JSONNull?, flaithship: JSONNull?, flavia: JSONNull?, gruffly: JSONNull?, hedychium: JSONNull?, leadwort: JSONNull?, overseriously: JSONNull?, parabola: JSONNull?, pectinatodenticulate: JSONNull?, popean: JSONNull?, pornocrat: JSONNull?, quadrisect: JSONNull?, seriality: JSONNull?, vamphorn: JSONNull?, wharp: JSONNull?) { + self.ammonolytic = ammonolytic + self.bushmaster = bushmaster + self.considering = considering + self.consuetudinary = consuetudinary + self.embarras = embarras + self.fineness = fineness + self.flaithship = flaithship + self.flavia = flavia + self.gruffly = gruffly + self.hedychium = hedychium + self.leadwort = leadwort + self.overseriously = overseriously + self.parabola = parabola + self.pectinatodenticulate = pectinatodenticulate + self.popean = popean + self.pornocrat = pornocrat + self.quadrisect = quadrisect + self.seriality = seriality + self.vamphorn = vamphorn + self.wharp = wharp + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CredulityClass.self, from: data) + self.init(ammonolytic: me.ammonolytic, bushmaster: me.bushmaster, considering: me.considering, consuetudinary: me.consuetudinary, embarras: me.embarras, fineness: me.fineness, flaithship: me.flaithship, flavia: me.flavia, gruffly: me.gruffly, hedychium: me.hedychium, leadwort: me.leadwort, overseriously: me.overseriously, parabola: me.parabola, pectinatodenticulate: me.pectinatodenticulate, popean: me.popean, pornocrat: me.pornocrat, quadrisect: me.quadrisect, seriality: me.seriality, vamphorn: me.vamphorn, wharp: me.wharp) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + ammonolytic: JSONNull?? = nil, + bushmaster: JSONNull?? = nil, + considering: JSONNull?? = nil, + consuetudinary: JSONNull?? = nil, + embarras: JSONNull?? = nil, + fineness: JSONNull?? = nil, + flaithship: JSONNull?? = nil, + flavia: JSONNull?? = nil, + gruffly: JSONNull?? = nil, + hedychium: JSONNull?? = nil, + leadwort: JSONNull?? = nil, + overseriously: JSONNull?? = nil, + parabola: JSONNull?? = nil, + pectinatodenticulate: JSONNull?? = nil, + popean: JSONNull?? = nil, + pornocrat: JSONNull?? = nil, + quadrisect: JSONNull?? = nil, + seriality: JSONNull?? = nil, + vamphorn: JSONNull?? = nil, + wharp: JSONNull?? = nil + ) -> CredulityClass { + return CredulityClass( + ammonolytic: ammonolytic ?? self.ammonolytic, + bushmaster: bushmaster ?? self.bushmaster, + considering: considering ?? self.considering, + consuetudinary: consuetudinary ?? self.consuetudinary, + embarras: embarras ?? self.embarras, + fineness: fineness ?? self.fineness, + flaithship: flaithship ?? self.flaithship, + flavia: flavia ?? self.flavia, + gruffly: gruffly ?? self.gruffly, + hedychium: hedychium ?? self.hedychium, + leadwort: leadwort ?? self.leadwort, + overseriously: overseriously ?? self.overseriously, + parabola: parabola ?? self.parabola, + pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate, + popean: popean ?? self.popean, + pornocrat: pornocrat ?? self.pornocrat, + quadrisect: quadrisect ?? self.quadrisect, + seriality: seriality ?? self.seriality, + vamphorn: vamphorn ?? self.vamphorn, + wharp: wharp ?? self.wharp + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Creviced: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum DeruralizeElement: Codable, Sendable { + case bool(Bool) + case deruralizeClass(DeruralizeClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(DeruralizeClass.self) { + self = .deruralizeClass(x) + return + } + throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .deruralizeClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DeruralizeClass +final class DeruralizeClass: Codable, Sendable { + let bockerel: JSONNull? + let boulder: JSONNull? + let churrus: JSONNull? + let counterdigged: JSONNull? + let dialogite: JSONNull? + let digenic: JSONNull? + let dunbird: JSONNull? + let ergatogyne: JSONNull? + let fiendful: JSONNull? + let jackrod: JSONNull? + let jehovistic: JSONNull? + let paninean: JSONNull? + let panther: JSONNull? + let placentigerous: JSONNull? + let romney: JSONNull? + let sparm: JSONNull? + let tocsin: JSONNull? + let unnicked: JSONNull? + let unstavable: JSONNull? + let windfirm: JSONNull? + + enum CodingKeys: String, CodingKey { + case bockerel = "bockerel" + case boulder = "boulder" + case churrus = "churrus" + case counterdigged = "counterdigged" + case dialogite = "dialogite" + case digenic = "digenic" + case dunbird = "dunbird" + case ergatogyne = "ergatogyne" + case fiendful = "fiendful" + case jackrod = "jackrod" + case jehovistic = "Jehovistic" + case paninean = "Paninean" + case panther = "panther" + case placentigerous = "placentigerous" + case romney = "Romney" + case sparm = "sparm" + case tocsin = "tocsin" + case unnicked = "unnicked" + case unstavable = "unstavable" + case windfirm = "windfirm" + } + + init(bockerel: JSONNull?, boulder: JSONNull?, churrus: JSONNull?, counterdigged: JSONNull?, dialogite: JSONNull?, digenic: JSONNull?, dunbird: JSONNull?, ergatogyne: JSONNull?, fiendful: JSONNull?, jackrod: JSONNull?, jehovistic: JSONNull?, paninean: JSONNull?, panther: JSONNull?, placentigerous: JSONNull?, romney: JSONNull?, sparm: JSONNull?, tocsin: JSONNull?, unnicked: JSONNull?, unstavable: JSONNull?, windfirm: JSONNull?) { + self.bockerel = bockerel + self.boulder = boulder + self.churrus = churrus + self.counterdigged = counterdigged + self.dialogite = dialogite + self.digenic = digenic + self.dunbird = dunbird + self.ergatogyne = ergatogyne + self.fiendful = fiendful + self.jackrod = jackrod + self.jehovistic = jehovistic + self.paninean = paninean + self.panther = panther + self.placentigerous = placentigerous + self.romney = romney + self.sparm = sparm + self.tocsin = tocsin + self.unnicked = unnicked + self.unstavable = unstavable + self.windfirm = windfirm + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DeruralizeClass.self, from: data) + self.init(bockerel: me.bockerel, boulder: me.boulder, churrus: me.churrus, counterdigged: me.counterdigged, dialogite: me.dialogite, digenic: me.digenic, dunbird: me.dunbird, ergatogyne: me.ergatogyne, fiendful: me.fiendful, jackrod: me.jackrod, jehovistic: me.jehovistic, paninean: me.paninean, panther: me.panther, placentigerous: me.placentigerous, romney: me.romney, sparm: me.sparm, tocsin: me.tocsin, unnicked: me.unnicked, unstavable: me.unstavable, windfirm: me.windfirm) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bockerel: JSONNull?? = nil, + boulder: JSONNull?? = nil, + churrus: JSONNull?? = nil, + counterdigged: JSONNull?? = nil, + dialogite: JSONNull?? = nil, + digenic: JSONNull?? = nil, + dunbird: JSONNull?? = nil, + ergatogyne: JSONNull?? = nil, + fiendful: JSONNull?? = nil, + jackrod: JSONNull?? = nil, + jehovistic: JSONNull?? = nil, + paninean: JSONNull?? = nil, + panther: JSONNull?? = nil, + placentigerous: JSONNull?? = nil, + romney: JSONNull?? = nil, + sparm: JSONNull?? = nil, + tocsin: JSONNull?? = nil, + unnicked: JSONNull?? = nil, + unstavable: JSONNull?? = nil, + windfirm: JSONNull?? = nil + ) -> DeruralizeClass { + return DeruralizeClass( + bockerel: bockerel ?? self.bockerel, + boulder: boulder ?? self.boulder, + churrus: churrus ?? self.churrus, + counterdigged: counterdigged ?? self.counterdigged, + dialogite: dialogite ?? self.dialogite, + digenic: digenic ?? self.digenic, + dunbird: dunbird ?? self.dunbird, + ergatogyne: ergatogyne ?? self.ergatogyne, + fiendful: fiendful ?? self.fiendful, + jackrod: jackrod ?? self.jackrod, + jehovistic: jehovistic ?? self.jehovistic, + paninean: paninean ?? self.paninean, + panther: panther ?? self.panther, + placentigerous: placentigerous ?? self.placentigerous, + romney: romney ?? self.romney, + sparm: sparm ?? self.sparm, + tocsin: tocsin ?? self.tocsin, + unnicked: unnicked ?? self.unnicked, + unstavable: unstavable ?? self.unstavable, + windfirm: windfirm ?? self.windfirm + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable, Sendable { + case bool(Bool) + case diaereseClass(DiaereseClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiaereseClass.self) { + self = .diaereseClass(x) + return + } + throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .diaereseClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiaereseClass +final class DiaereseClass: Codable, Sendable { + let amoreuxia: JSONNull? + let ani: JSONNull? + let bernicle: JSONNull? + let blackwasher: JSONNull? + let blowhard: JSONNull? + let broma: JSONNull? + let closecross: JSONNull? + let congregationalism: JSONNull? + let grayly: JSONNull? + let historically: JSONNull? + let hoast: JSONNull? + let irretentive: JSONNull? + let parcener: JSONNull? + let pedder: JSONNull? + let pseudoanatomic: JSONNull? + let rhizocarpian: JSONNull? + let samel: JSONNull? + let silker: JSONNull? + let subdentated: JSONNull? + let subobscure: JSONNull? + + enum CodingKeys: String, CodingKey { + case amoreuxia = "Amoreuxia" + case ani = "ani" + case bernicle = "bernicle" + case blackwasher = "blackwasher" + case blowhard = "blowhard" + case broma = "broma" + case closecross = "closecross" + case congregationalism = "congregationalism" + case grayly = "grayly" + case historically = "historically" + case hoast = "hoast" + case irretentive = "irretentive" + case parcener = "parcener" + case pedder = "pedder" + case pseudoanatomic = "pseudoanatomic" + case rhizocarpian = "rhizocarpian" + case samel = "samel" + case silker = "silker" + case subdentated = "subdentated" + case subobscure = "subobscure" + } + + init(amoreuxia: JSONNull?, ani: JSONNull?, bernicle: JSONNull?, blackwasher: JSONNull?, blowhard: JSONNull?, broma: JSONNull?, closecross: JSONNull?, congregationalism: JSONNull?, grayly: JSONNull?, historically: JSONNull?, hoast: JSONNull?, irretentive: JSONNull?, parcener: JSONNull?, pedder: JSONNull?, pseudoanatomic: JSONNull?, rhizocarpian: JSONNull?, samel: JSONNull?, silker: JSONNull?, subdentated: JSONNull?, subobscure: JSONNull?) { + self.amoreuxia = amoreuxia + self.ani = ani + self.bernicle = bernicle + self.blackwasher = blackwasher + self.blowhard = blowhard + self.broma = broma + self.closecross = closecross + self.congregationalism = congregationalism + self.grayly = grayly + self.historically = historically + self.hoast = hoast + self.irretentive = irretentive + self.parcener = parcener + self.pedder = pedder + self.pseudoanatomic = pseudoanatomic + self.rhizocarpian = rhizocarpian + self.samel = samel + self.silker = silker + self.subdentated = subdentated + self.subobscure = subobscure + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiaereseClass.self, from: data) + self.init(amoreuxia: me.amoreuxia, ani: me.ani, bernicle: me.bernicle, blackwasher: me.blackwasher, blowhard: me.blowhard, broma: me.broma, closecross: me.closecross, congregationalism: me.congregationalism, grayly: me.grayly, historically: me.historically, hoast: me.hoast, irretentive: me.irretentive, parcener: me.parcener, pedder: me.pedder, pseudoanatomic: me.pseudoanatomic, rhizocarpian: me.rhizocarpian, samel: me.samel, silker: me.silker, subdentated: me.subdentated, subobscure: me.subobscure) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amoreuxia: JSONNull?? = nil, + ani: JSONNull?? = nil, + bernicle: JSONNull?? = nil, + blackwasher: JSONNull?? = nil, + blowhard: JSONNull?? = nil, + broma: JSONNull?? = nil, + closecross: JSONNull?? = nil, + congregationalism: JSONNull?? = nil, + grayly: JSONNull?? = nil, + historically: JSONNull?? = nil, + hoast: JSONNull?? = nil, + irretentive: JSONNull?? = nil, + parcener: JSONNull?? = nil, + pedder: JSONNull?? = nil, + pseudoanatomic: JSONNull?? = nil, + rhizocarpian: JSONNull?? = nil, + samel: JSONNull?? = nil, + silker: JSONNull?? = nil, + subdentated: JSONNull?? = nil, + subobscure: JSONNull?? = nil + ) -> DiaereseClass { + return DiaereseClass( + amoreuxia: amoreuxia ?? self.amoreuxia, + ani: ani ?? self.ani, + bernicle: bernicle ?? self.bernicle, + blackwasher: blackwasher ?? self.blackwasher, + blowhard: blowhard ?? self.blowhard, + broma: broma ?? self.broma, + closecross: closecross ?? self.closecross, + congregationalism: congregationalism ?? self.congregationalism, + grayly: grayly ?? self.grayly, + historically: historically ?? self.historically, + hoast: hoast ?? self.hoast, + irretentive: irretentive ?? self.irretentive, + parcener: parcener ?? self.parcener, + pedder: pedder ?? self.pedder, + pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic, + rhizocarpian: rhizocarpian ?? self.rhizocarpian, + samel: samel ?? self.samel, + silker: silker ?? self.silker, + subdentated: subdentated ?? self.subdentated, + subobscure: subobscure ?? self.subobscure + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Downstroke: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eleutheromania: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Encrust +final class Encrust: Codable, Sendable { + let comradely: JSONNull? + let diacanthous: JSONNull? + let feminineness: JSONNull? + let gossamered: JSONNull? + let hibernia: JSONNull? + let hibiscus: JSONNull? + let lepidosauria: JSONNull? + let lollingly: JSONNull? + let manager: JSONNull? + let mechanic: JSONNull? + let overminuteness: JSONNull? + let papelonne: JSONNull? + let plebification: JSONNull? + let pugmiller: JSONNull? + let recoveror: JSONNull? + let spermatoblastic: JSONNull? + let syllidae: JSONNull? + let ungyved: JSONNull? + let whirlabout: JSONNull? + let woodenware: JSONNull? + + enum CodingKeys: String, CodingKey { + case comradely = "comradely" + case diacanthous = "diacanthous" + case feminineness = "feminineness" + case gossamered = "gossamered" + case hibernia = "Hibernia" + case hibiscus = "Hibiscus" + case lepidosauria = "Lepidosauria" + case lollingly = "lollingly" + case manager = "manager" + case mechanic = "mechanic" + case overminuteness = "overminuteness" + case papelonne = "papelonne" + case plebification = "plebification" + case pugmiller = "pugmiller" + case recoveror = "recoveror" + case spermatoblastic = "spermatoblastic" + case syllidae = "Syllidae" + case ungyved = "ungyved" + case whirlabout = "whirlabout" + case woodenware = "woodenware" + } + + init(comradely: JSONNull?, diacanthous: JSONNull?, feminineness: JSONNull?, gossamered: JSONNull?, hibernia: JSONNull?, hibiscus: JSONNull?, lepidosauria: JSONNull?, lollingly: JSONNull?, manager: JSONNull?, mechanic: JSONNull?, overminuteness: JSONNull?, papelonne: JSONNull?, plebification: JSONNull?, pugmiller: JSONNull?, recoveror: JSONNull?, spermatoblastic: JSONNull?, syllidae: JSONNull?, ungyved: JSONNull?, whirlabout: JSONNull?, woodenware: JSONNull?) { + self.comradely = comradely + self.diacanthous = diacanthous + self.feminineness = feminineness + self.gossamered = gossamered + self.hibernia = hibernia + self.hibiscus = hibiscus + self.lepidosauria = lepidosauria + self.lollingly = lollingly + self.manager = manager + self.mechanic = mechanic + self.overminuteness = overminuteness + self.papelonne = papelonne + self.plebification = plebification + self.pugmiller = pugmiller + self.recoveror = recoveror + self.spermatoblastic = spermatoblastic + self.syllidae = syllidae + self.ungyved = ungyved + self.whirlabout = whirlabout + self.woodenware = woodenware + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Encrust.self, from: data) + self.init(comradely: me.comradely, diacanthous: me.diacanthous, feminineness: me.feminineness, gossamered: me.gossamered, hibernia: me.hibernia, hibiscus: me.hibiscus, lepidosauria: me.lepidosauria, lollingly: me.lollingly, manager: me.manager, mechanic: me.mechanic, overminuteness: me.overminuteness, papelonne: me.papelonne, plebification: me.plebification, pugmiller: me.pugmiller, recoveror: me.recoveror, spermatoblastic: me.spermatoblastic, syllidae: me.syllidae, ungyved: me.ungyved, whirlabout: me.whirlabout, woodenware: me.woodenware) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + comradely: JSONNull?? = nil, + diacanthous: JSONNull?? = nil, + feminineness: JSONNull?? = nil, + gossamered: JSONNull?? = nil, + hibernia: JSONNull?? = nil, + hibiscus: JSONNull?? = nil, + lepidosauria: JSONNull?? = nil, + lollingly: JSONNull?? = nil, + manager: JSONNull?? = nil, + mechanic: JSONNull?? = nil, + overminuteness: JSONNull?? = nil, + papelonne: JSONNull?? = nil, + plebification: JSONNull?? = nil, + pugmiller: JSONNull?? = nil, + recoveror: JSONNull?? = nil, + spermatoblastic: JSONNull?? = nil, + syllidae: JSONNull?? = nil, + ungyved: JSONNull?? = nil, + whirlabout: JSONNull?? = nil, + woodenware: JSONNull?? = nil + ) -> Encrust { + return Encrust( + comradely: comradely ?? self.comradely, + diacanthous: diacanthous ?? self.diacanthous, + feminineness: feminineness ?? self.feminineness, + gossamered: gossamered ?? self.gossamered, + hibernia: hibernia ?? self.hibernia, + hibiscus: hibiscus ?? self.hibiscus, + lepidosauria: lepidosauria ?? self.lepidosauria, + lollingly: lollingly ?? self.lollingly, + manager: manager ?? self.manager, + mechanic: mechanic ?? self.mechanic, + overminuteness: overminuteness ?? self.overminuteness, + papelonne: papelonne ?? self.papelonne, + plebification: plebification ?? self.plebification, + pugmiller: pugmiller ?? self.pugmiller, + recoveror: recoveror ?? self.recoveror, + spermatoblastic: spermatoblastic ?? self.spermatoblastic, + syllidae: syllidae ?? self.syllidae, + ungyved: ungyved ?? self.ungyved, + whirlabout: whirlabout ?? self.whirlabout, + woodenware: woodenware ?? self.woodenware + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Epipaleolithic: Codable, Sendable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Expropriable: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum FagginglyElement: Codable, Sendable { + case double(Double) + case fagginglyClass(FagginglyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FagginglyClass.self) { + self = .fagginglyClass(x) + return + } + throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .fagginglyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FagginglyClass +final class FagginglyClass: Codable, Sendable { + let abranchian: JSONNull? + let aculeiform: JSONNull? + let adiaphoristic: JSONNull? + let adoptionism: JSONNull? + let anglic: JSONNull? + let antrotomy: JSONNull? + let coerciveness: JSONNull? + let decorist: JSONNull? + let duckhood: JSONNull? + let heteromeri: JSONNull? + let hypochnose: JSONNull? + let lochage: JSONNull? + let melee: JSONNull? + let nonconformitant: JSONNull? + let poinsettia: JSONNull? + let putatively: JSONNull? + let semivolatile: JSONNull? + let soleas: JSONNull? + let unfastenable: JSONNull? + let unmillinered: JSONNull? + + enum CodingKeys: String, CodingKey { + case abranchian = "abranchian" + case aculeiform = "aculeiform" + case adiaphoristic = "adiaphoristic" + case adoptionism = "adoptionism" + case anglic = "Anglic" + case antrotomy = "antrotomy" + case coerciveness = "coerciveness" + case decorist = "decorist" + case duckhood = "duckhood" + case heteromeri = "Heteromeri" + case hypochnose = "hypochnose" + case lochage = "lochage" + case melee = "melee" + case nonconformitant = "nonconformitant" + case poinsettia = "Poinsettia" + case putatively = "putatively" + case semivolatile = "semivolatile" + case soleas = "soleas" + case unfastenable = "unfastenable" + case unmillinered = "unmillinered" + } + + init(abranchian: JSONNull?, aculeiform: JSONNull?, adiaphoristic: JSONNull?, adoptionism: JSONNull?, anglic: JSONNull?, antrotomy: JSONNull?, coerciveness: JSONNull?, decorist: JSONNull?, duckhood: JSONNull?, heteromeri: JSONNull?, hypochnose: JSONNull?, lochage: JSONNull?, melee: JSONNull?, nonconformitant: JSONNull?, poinsettia: JSONNull?, putatively: JSONNull?, semivolatile: JSONNull?, soleas: JSONNull?, unfastenable: JSONNull?, unmillinered: JSONNull?) { + self.abranchian = abranchian + self.aculeiform = aculeiform + self.adiaphoristic = adiaphoristic + self.adoptionism = adoptionism + self.anglic = anglic + self.antrotomy = antrotomy + self.coerciveness = coerciveness + self.decorist = decorist + self.duckhood = duckhood + self.heteromeri = heteromeri + self.hypochnose = hypochnose + self.lochage = lochage + self.melee = melee + self.nonconformitant = nonconformitant + self.poinsettia = poinsettia + self.putatively = putatively + self.semivolatile = semivolatile + self.soleas = soleas + self.unfastenable = unfastenable + self.unmillinered = unmillinered + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FagginglyClass.self, from: data) + self.init(abranchian: me.abranchian, aculeiform: me.aculeiform, adiaphoristic: me.adiaphoristic, adoptionism: me.adoptionism, anglic: me.anglic, antrotomy: me.antrotomy, coerciveness: me.coerciveness, decorist: me.decorist, duckhood: me.duckhood, heteromeri: me.heteromeri, hypochnose: me.hypochnose, lochage: me.lochage, melee: me.melee, nonconformitant: me.nonconformitant, poinsettia: me.poinsettia, putatively: me.putatively, semivolatile: me.semivolatile, soleas: me.soleas, unfastenable: me.unfastenable, unmillinered: me.unmillinered) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchian: JSONNull?? = nil, + aculeiform: JSONNull?? = nil, + adiaphoristic: JSONNull?? = nil, + adoptionism: JSONNull?? = nil, + anglic: JSONNull?? = nil, + antrotomy: JSONNull?? = nil, + coerciveness: JSONNull?? = nil, + decorist: JSONNull?? = nil, + duckhood: JSONNull?? = nil, + heteromeri: JSONNull?? = nil, + hypochnose: JSONNull?? = nil, + lochage: JSONNull?? = nil, + melee: JSONNull?? = nil, + nonconformitant: JSONNull?? = nil, + poinsettia: JSONNull?? = nil, + putatively: JSONNull?? = nil, + semivolatile: JSONNull?? = nil, + soleas: JSONNull?? = nil, + unfastenable: JSONNull?? = nil, + unmillinered: JSONNull?? = nil + ) -> FagginglyClass { + return FagginglyClass( + abranchian: abranchian ?? self.abranchian, + aculeiform: aculeiform ?? self.aculeiform, + adiaphoristic: adiaphoristic ?? self.adiaphoristic, + adoptionism: adoptionism ?? self.adoptionism, + anglic: anglic ?? self.anglic, + antrotomy: antrotomy ?? self.antrotomy, + coerciveness: coerciveness ?? self.coerciveness, + decorist: decorist ?? self.decorist, + duckhood: duckhood ?? self.duckhood, + heteromeri: heteromeri ?? self.heteromeri, + hypochnose: hypochnose ?? self.hypochnose, + lochage: lochage ?? self.lochage, + melee: melee ?? self.melee, + nonconformitant: nonconformitant ?? self.nonconformitant, + poinsettia: poinsettia ?? self.poinsettia, + putatively: putatively ?? self.putatively, + semivolatile: semivolatile ?? self.semivolatile, + soleas: soleas ?? self.soleas, + unfastenable: unfastenable ?? self.unfastenable, + unmillinered: unmillinered ?? self.unmillinered + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable, Sendable { + case fenkClass(FenkClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(FenkClass.self) { + self = .fenkClass(x) + return + } + throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .fenkClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - FenkClass +final class FenkClass: Codable, Sendable { + let apoise: JSONNull? + let astronomize: JSONNull? + let cockhorse: JSONNull? + let copular: JSONNull? + let dagomba: JSONNull? + let draffy: JSONNull? + let foreigner: JSONNull? + let guyandot: JSONNull? + let neurogliosis: JSONNull? + let osmious: JSONNull? + let palpitate: JSONNull? + let rebukeable: JSONNull? + let reinwardtia: JSONNull? + let reservatory: JSONNull? + let scalt: JSONNull? + let scripturalize: JSONNull? + let tintometer: JSONNull? + let tritoness: JSONNull? + let undergrade: JSONNull? + let undermountain: JSONNull? + + enum CodingKeys: String, CodingKey { + case apoise = "apoise" + case astronomize = "astronomize" + case cockhorse = "cockhorse" + case copular = "copular" + case dagomba = "Dagomba" + case draffy = "draffy" + case foreigner = "foreigner" + case guyandot = "Guyandot" + case neurogliosis = "neurogliosis" + case osmious = "osmious" + case palpitate = "palpitate" + case rebukeable = "rebukeable" + case reinwardtia = "Reinwardtia" + case reservatory = "reservatory" + case scalt = "scalt" + case scripturalize = "scripturalize" + case tintometer = "tintometer" + case tritoness = "Tritoness" + case undergrade = "undergrade" + case undermountain = "undermountain" + } + + init(apoise: JSONNull?, astronomize: JSONNull?, cockhorse: JSONNull?, copular: JSONNull?, dagomba: JSONNull?, draffy: JSONNull?, foreigner: JSONNull?, guyandot: JSONNull?, neurogliosis: JSONNull?, osmious: JSONNull?, palpitate: JSONNull?, rebukeable: JSONNull?, reinwardtia: JSONNull?, reservatory: JSONNull?, scalt: JSONNull?, scripturalize: JSONNull?, tintometer: JSONNull?, tritoness: JSONNull?, undergrade: JSONNull?, undermountain: JSONNull?) { + self.apoise = apoise + self.astronomize = astronomize + self.cockhorse = cockhorse + self.copular = copular + self.dagomba = dagomba + self.draffy = draffy + self.foreigner = foreigner + self.guyandot = guyandot + self.neurogliosis = neurogliosis + self.osmious = osmious + self.palpitate = palpitate + self.rebukeable = rebukeable + self.reinwardtia = reinwardtia + self.reservatory = reservatory + self.scalt = scalt + self.scripturalize = scripturalize + self.tintometer = tintometer + self.tritoness = tritoness + self.undergrade = undergrade + self.undermountain = undermountain + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FenkClass.self, from: data) + self.init(apoise: me.apoise, astronomize: me.astronomize, cockhorse: me.cockhorse, copular: me.copular, dagomba: me.dagomba, draffy: me.draffy, foreigner: me.foreigner, guyandot: me.guyandot, neurogliosis: me.neurogliosis, osmious: me.osmious, palpitate: me.palpitate, rebukeable: me.rebukeable, reinwardtia: me.reinwardtia, reservatory: me.reservatory, scalt: me.scalt, scripturalize: me.scripturalize, tintometer: me.tintometer, tritoness: me.tritoness, undergrade: me.undergrade, undermountain: me.undermountain) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apoise: JSONNull?? = nil, + astronomize: JSONNull?? = nil, + cockhorse: JSONNull?? = nil, + copular: JSONNull?? = nil, + dagomba: JSONNull?? = nil, + draffy: JSONNull?? = nil, + foreigner: JSONNull?? = nil, + guyandot: JSONNull?? = nil, + neurogliosis: JSONNull?? = nil, + osmious: JSONNull?? = nil, + palpitate: JSONNull?? = nil, + rebukeable: JSONNull?? = nil, + reinwardtia: JSONNull?? = nil, + reservatory: JSONNull?? = nil, + scalt: JSONNull?? = nil, + scripturalize: JSONNull?? = nil, + tintometer: JSONNull?? = nil, + tritoness: JSONNull?? = nil, + undergrade: JSONNull?? = nil, + undermountain: JSONNull?? = nil + ) -> FenkClass { + return FenkClass( + apoise: apoise ?? self.apoise, + astronomize: astronomize ?? self.astronomize, + cockhorse: cockhorse ?? self.cockhorse, + copular: copular ?? self.copular, + dagomba: dagomba ?? self.dagomba, + draffy: draffy ?? self.draffy, + foreigner: foreigner ?? self.foreigner, + guyandot: guyandot ?? self.guyandot, + neurogliosis: neurogliosis ?? self.neurogliosis, + osmious: osmious ?? self.osmious, + palpitate: palpitate ?? self.palpitate, + rebukeable: rebukeable ?? self.rebukeable, + reinwardtia: reinwardtia ?? self.reinwardtia, + reservatory: reservatory ?? self.reservatory, + scalt: scalt ?? self.scalt, + scripturalize: scripturalize ?? self.scripturalize, + tintometer: tintometer ?? self.tintometer, + tritoness: tritoness ?? self.tritoness, + undergrade: undergrade ?? self.undergrade, + undermountain: undermountain ?? self.undermountain + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable, Sendable { + case bool(Bool) + case double(Double) + case flagmakingClass(FlagmakingClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FlagmakingClass.self) { + self = .flagmakingClass(x) + return + } + throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .flagmakingClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FlagmakingClass +final class FlagmakingClass: Codable, Sendable { + let albarco: JSONNull? + let bunodonta: JSONNull? + let hornify: JSONNull? + let hydrocorisae: JSONNull? + let hypoglossus: JSONNull? + let inexpiably: JSONNull? + let ingratitude: JSONNull? + let ladyfly: JSONNull? + let medicament: JSONNull? + let monogrammatic: JSONNull? + let nobbut: JSONNull? + let notacanthidae: JSONNull? + let polyplacophore: JSONNull? + let proexercise: JSONNull? + let protoplast: JSONNull? + let puzzling: JSONNull? + let splanchnoskeleton: JSONNull? + let unloveliness: JSONNull? + let unquarantined: JSONNull? + let unrenounceable: JSONNull? + + enum CodingKeys: String, CodingKey { + case albarco = "albarco" + case bunodonta = "Bunodonta" + case hornify = "hornify" + case hydrocorisae = "Hydrocorisae" + case hypoglossus = "hypoglossus" + case inexpiably = "inexpiably" + case ingratitude = "ingratitude" + case ladyfly = "ladyfly" + case medicament = "medicament" + case monogrammatic = "monogrammatic" + case nobbut = "nobbut" + case notacanthidae = "Notacanthidae" + case polyplacophore = "polyplacophore" + case proexercise = "proexercise" + case protoplast = "protoplast" + case puzzling = "puzzling" + case splanchnoskeleton = "splanchnoskeleton" + case unloveliness = "unloveliness" + case unquarantined = "unquarantined" + case unrenounceable = "unrenounceable" + } + + init(albarco: JSONNull?, bunodonta: JSONNull?, hornify: JSONNull?, hydrocorisae: JSONNull?, hypoglossus: JSONNull?, inexpiably: JSONNull?, ingratitude: JSONNull?, ladyfly: JSONNull?, medicament: JSONNull?, monogrammatic: JSONNull?, nobbut: JSONNull?, notacanthidae: JSONNull?, polyplacophore: JSONNull?, proexercise: JSONNull?, protoplast: JSONNull?, puzzling: JSONNull?, splanchnoskeleton: JSONNull?, unloveliness: JSONNull?, unquarantined: JSONNull?, unrenounceable: JSONNull?) { + self.albarco = albarco + self.bunodonta = bunodonta + self.hornify = hornify + self.hydrocorisae = hydrocorisae + self.hypoglossus = hypoglossus + self.inexpiably = inexpiably + self.ingratitude = ingratitude + self.ladyfly = ladyfly + self.medicament = medicament + self.monogrammatic = monogrammatic + self.nobbut = nobbut + self.notacanthidae = notacanthidae + self.polyplacophore = polyplacophore + self.proexercise = proexercise + self.protoplast = protoplast + self.puzzling = puzzling + self.splanchnoskeleton = splanchnoskeleton + self.unloveliness = unloveliness + self.unquarantined = unquarantined + self.unrenounceable = unrenounceable + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FlagmakingClass.self, from: data) + self.init(albarco: me.albarco, bunodonta: me.bunodonta, hornify: me.hornify, hydrocorisae: me.hydrocorisae, hypoglossus: me.hypoglossus, inexpiably: me.inexpiably, ingratitude: me.ingratitude, ladyfly: me.ladyfly, medicament: me.medicament, monogrammatic: me.monogrammatic, nobbut: me.nobbut, notacanthidae: me.notacanthidae, polyplacophore: me.polyplacophore, proexercise: me.proexercise, protoplast: me.protoplast, puzzling: me.puzzling, splanchnoskeleton: me.splanchnoskeleton, unloveliness: me.unloveliness, unquarantined: me.unquarantined, unrenounceable: me.unrenounceable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + albarco: JSONNull?? = nil, + bunodonta: JSONNull?? = nil, + hornify: JSONNull?? = nil, + hydrocorisae: JSONNull?? = nil, + hypoglossus: JSONNull?? = nil, + inexpiably: JSONNull?? = nil, + ingratitude: JSONNull?? = nil, + ladyfly: JSONNull?? = nil, + medicament: JSONNull?? = nil, + monogrammatic: JSONNull?? = nil, + nobbut: JSONNull?? = nil, + notacanthidae: JSONNull?? = nil, + polyplacophore: JSONNull?? = nil, + proexercise: JSONNull?? = nil, + protoplast: JSONNull?? = nil, + puzzling: JSONNull?? = nil, + splanchnoskeleton: JSONNull?? = nil, + unloveliness: JSONNull?? = nil, + unquarantined: JSONNull?? = nil, + unrenounceable: JSONNull?? = nil + ) -> FlagmakingClass { + return FlagmakingClass( + albarco: albarco ?? self.albarco, + bunodonta: bunodonta ?? self.bunodonta, + hornify: hornify ?? self.hornify, + hydrocorisae: hydrocorisae ?? self.hydrocorisae, + hypoglossus: hypoglossus ?? self.hypoglossus, + inexpiably: inexpiably ?? self.inexpiably, + ingratitude: ingratitude ?? self.ingratitude, + ladyfly: ladyfly ?? self.ladyfly, + medicament: medicament ?? self.medicament, + monogrammatic: monogrammatic ?? self.monogrammatic, + nobbut: nobbut ?? self.nobbut, + notacanthidae: notacanthidae ?? self.notacanthidae, + polyplacophore: polyplacophore ?? self.polyplacophore, + proexercise: proexercise ?? self.proexercise, + protoplast: protoplast ?? self.protoplast, + puzzling: puzzling ?? self.puzzling, + splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton, + unloveliness: unloveliness ?? self.unloveliness, + unquarantined: unquarantined ?? self.unquarantined, + unrenounceable: unrenounceable ?? self.unrenounceable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Fluorometer: Codable, Sendable { + case integer(Int) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Fuzzy: Codable, Sendable { + case integer(Int) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Gardenward: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Generalissimo: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hemicrystalline: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum HemocoeleElement: Codable, Sendable { + case hemocoeleClass(HemocoeleClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(HemocoeleClass.self) { + self = .hemocoeleClass(x) + return + } + throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .hemocoeleClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - HemocoeleClass +final class HemocoeleClass: Codable, Sendable { + let acrogamy: JSONNull? + let amelification: JSONNull? + let autobiographic: JSONNull? + let berat: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let disproportionably: JSONNull? + let erythrite: JSONNull? + let graphic: JSONNull? + let hepatological: JSONNull? + let homocerc: Bool? + let incommensurably: JSONNull? + let misaffirm: JSONNull? + let nonbookish: JSONNull? + let pocketbook: JSONNull? + let sclerometric: JSONNull? + let stambouline: JSONNull? + let stickpin: JSONNull? + let tubulure: JSONNull? + let undelated: JSONNull? + let unsalt: JSONNull? + let untutelar: JSONNull? + let vagrant: JSONNull? + let walt: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrogamy = "acrogamy" + case amelification = "amelification" + case autobiographic = "autobiographic" + case berat = "berat" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case disproportionably = "disproportionably" + case erythrite = "erythrite" + case graphic = "graphic" + case hepatological = "hepatological" + case homocerc = "homocerc" + case incommensurably = "incommensurably" + case misaffirm = "misaffirm" + case nonbookish = "nonbookish" + case pocketbook = "pocketbook" + case sclerometric = "sclerometric" + case stambouline = "stambouline" + case stickpin = "stickpin" + case tubulure = "tubulure" + case undelated = "undelated" + case unsalt = "unsalt" + case untutelar = "untutelar" + case vagrant = "vagrant" + case walt = "Walt" + } + + init(acrogamy: JSONNull?, amelification: JSONNull?, autobiographic: JSONNull?, berat: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, disproportionably: JSONNull?, erythrite: JSONNull?, graphic: JSONNull?, hepatological: JSONNull?, homocerc: Bool?, incommensurably: JSONNull?, misaffirm: JSONNull?, nonbookish: JSONNull?, pocketbook: JSONNull?, sclerometric: JSONNull?, stambouline: JSONNull?, stickpin: JSONNull?, tubulure: JSONNull?, undelated: JSONNull?, unsalt: JSONNull?, untutelar: JSONNull?, vagrant: JSONNull?, walt: JSONNull?) { + self.acrogamy = acrogamy + self.amelification = amelification + self.autobiographic = autobiographic + self.berat = berat + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.disproportionably = disproportionably + self.erythrite = erythrite + self.graphic = graphic + self.hepatological = hepatological + self.homocerc = homocerc + self.incommensurably = incommensurably + self.misaffirm = misaffirm + self.nonbookish = nonbookish + self.pocketbook = pocketbook + self.sclerometric = sclerometric + self.stambouline = stambouline + self.stickpin = stickpin + self.tubulure = tubulure + self.undelated = undelated + self.unsalt = unsalt + self.untutelar = untutelar + self.vagrant = vagrant + self.walt = walt + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(HemocoeleClass.self, from: data) + self.init(acrogamy: me.acrogamy, amelification: me.amelification, autobiographic: me.autobiographic, berat: me.berat, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, disproportionably: me.disproportionably, erythrite: me.erythrite, graphic: me.graphic, hepatological: me.hepatological, homocerc: me.homocerc, incommensurably: me.incommensurably, misaffirm: me.misaffirm, nonbookish: me.nonbookish, pocketbook: me.pocketbook, sclerometric: me.sclerometric, stambouline: me.stambouline, stickpin: me.stickpin, tubulure: me.tubulure, undelated: me.undelated, unsalt: me.unsalt, untutelar: me.untutelar, vagrant: me.vagrant, walt: me.walt) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrogamy: JSONNull?? = nil, + amelification: JSONNull?? = nil, + autobiographic: JSONNull?? = nil, + berat: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + disproportionably: JSONNull?? = nil, + erythrite: JSONNull?? = nil, + graphic: JSONNull?? = nil, + hepatological: JSONNull?? = nil, + homocerc: Bool?? = nil, + incommensurably: JSONNull?? = nil, + misaffirm: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + pocketbook: JSONNull?? = nil, + sclerometric: JSONNull?? = nil, + stambouline: JSONNull?? = nil, + stickpin: JSONNull?? = nil, + tubulure: JSONNull?? = nil, + undelated: JSONNull?? = nil, + unsalt: JSONNull?? = nil, + untutelar: JSONNull?? = nil, + vagrant: JSONNull?? = nil, + walt: JSONNull?? = nil + ) -> HemocoeleClass { + return HemocoeleClass( + acrogamy: acrogamy ?? self.acrogamy, + amelification: amelification ?? self.amelification, + autobiographic: autobiographic ?? self.autobiographic, + berat: berat ?? self.berat, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + disproportionably: disproportionably ?? self.disproportionably, + erythrite: erythrite ?? self.erythrite, + graphic: graphic ?? self.graphic, + hepatological: hepatological ?? self.hepatological, + homocerc: homocerc ?? self.homocerc, + incommensurably: incommensurably ?? self.incommensurably, + misaffirm: misaffirm ?? self.misaffirm, + nonbookish: nonbookish ?? self.nonbookish, + pocketbook: pocketbook ?? self.pocketbook, + sclerometric: sclerometric ?? self.sclerometric, + stambouline: stambouline ?? self.stambouline, + stickpin: stickpin ?? self.stickpin, + tubulure: tubulure ?? self.tubulure, + undelated: undelated ?? self.undelated, + unsalt: unsalt ?? self.unsalt, + untutelar: untutelar ?? self.untutelar, + vagrant: vagrant ?? self.vagrant, + walt: walt ?? self.walt + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyperpiesi: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyppish: Codable, Sendable { + case bool(Bool) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Idealizer: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Incrustator: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Intentiveness: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Interacinar +final class Interacinar: Codable, Sendable { + let assapan: Double + let benefactorship: Bool + let triseriatim: String + let tubbing: Int + let untrimmed: JSONNull? + + enum CodingKeys: String, CodingKey { + case assapan = "assapan" + case benefactorship = "benefactorship" + case triseriatim = "triseriatim" + case tubbing = "tubbing" + case untrimmed = "untrimmed" + } + + init(assapan: Double, benefactorship: Bool, triseriatim: String, tubbing: Int, untrimmed: JSONNull?) { + self.assapan = assapan + self.benefactorship = benefactorship + self.triseriatim = triseriatim + self.tubbing = tubbing + self.untrimmed = untrimmed + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Interacinar.self, from: data) + self.init(assapan: me.assapan, benefactorship: me.benefactorship, triseriatim: me.triseriatim, tubbing: me.tubbing, untrimmed: me.untrimmed) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + assapan: Double? = nil, + benefactorship: Bool? = nil, + triseriatim: String? = nil, + tubbing: Int? = nil, + untrimmed: JSONNull?? = nil + ) -> Interacinar { + return Interacinar( + assapan: assapan ?? self.assapan, + benefactorship: benefactorship ?? self.benefactorship, + triseriatim: triseriatim ?? self.triseriatim, + tubbing: tubbing ?? self.tubbing, + untrimmed: untrimmed ?? self.untrimmed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Jacutinga: Codable, Sendable { + case integerArray([Int]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations2.json/default/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations2.json/default/quicktype.swift new file mode 100644 index 0000000..9dc4ae1 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations2.json/default/quicktype.swift @@ -0,0 +1,2602 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Sendable { + let abranchiata: [Abranchiata] + let academe: [Academe] + let acquirable: [Acquirable] + let aerometry: [Aerometry] + let alexin: [Alexin] + let alleviate: [AlleviateElement] + let amaas: [Amaa] + let ambassage: [Ambassage] + let amphithyron: [Amphithyron?] + let andriana: [String?] + let ankee: [AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [AnsarieElement] + let aphasia: [Aphasia] + let asprawl: [Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [Bedesman] + let belard: [Belard] + let bocking: [Bocking] + let brawlingly: [Brawlingly] + let brookie: [Brookie] + let bumboatman: [Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [Calaverite] + let catallactic: [Catallactic] + let cemental: [Cemental] + let chytridiaceae: [ChytridiaceaeElement] + let discordia: [DiscordiaElement] + let endomyces: [Endomyce] + let epinephelidae: [Epinephelidae] + let eupatorium: [Eupatorium] + let gryphosaurus: [GryphosaurusElement] + let koryak: [Koryak] + let lavinia: [LaviniaElement] + let oskar: [OskarElement] + let rebecca: [RebeccaElement] + let rhomboganoidei: [Rhomboganoidei] + let rigsmal: Bool + let ruellia: [Ruellia] + let school: [School] + let shakespearolater: [Shakespearolater] + let svan: [Double] + let wayao: [String: Double] + + enum CodingKeys: String, CodingKey { + case abranchiata = "Abranchiata" + case academe = "academe" + case acquirable = "acquirable" + case aerometry = "aerometry" + case alexin = "alexin" + case alleviate = "alleviate" + case amaas = "amaas" + case ambassage = "ambassage" + case amphithyron = "amphithyron" + case andriana = "Andriana" + case ankee = "ankee" + case annihilator = "annihilator" + case annulose = "annulose" + case ansarie = "Ansarie" + case aphasia = "aphasia" + case asprawl = "asprawl" + case attractive = "attractive" + case barksome = "barksome" + case bedesman = "bedesman" + case belard = "belard" + case bocking = "bocking" + case brawlingly = "brawlingly" + case brookie = "brookie" + case bumboatman = "bumboatman" + case bystreet = "bystreet" + case calaverite = "calaverite" + case catallactic = "catallactic" + case cemental = "cemental" + case chytridiaceae = "Chytridiaceae" + case discordia = "Discordia" + case endomyces = "Endomyces" + case epinephelidae = "Epinephelidae" + case eupatorium = "Eupatorium" + case gryphosaurus = "Gryphosaurus" + case koryak = "Koryak" + case lavinia = "Lavinia" + case oskar = "Oskar" + case rebecca = "Rebecca" + case rhomboganoidei = "Rhomboganoidei" + case rigsmal = "Rigsmal" + case ruellia = "Ruellia" + case school = "School" + case shakespearolater = "Shakespearolater" + case svan = "Svan" + case wayao = "Wayao" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchiata: [Abranchiata]? = nil, + academe: [Academe]? = nil, + acquirable: [Acquirable]? = nil, + aerometry: [Aerometry]? = nil, + alexin: [Alexin]? = nil, + alleviate: [AlleviateElement]? = nil, + amaas: [Amaa]? = nil, + ambassage: [Ambassage]? = nil, + amphithyron: [Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [AnsarieElement]? = nil, + aphasia: [Aphasia]? = nil, + asprawl: [Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [Bedesman]? = nil, + belard: [Belard]? = nil, + bocking: [Bocking]? = nil, + brawlingly: [Brawlingly]? = nil, + brookie: [Brookie]? = nil, + bumboatman: [Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [Calaverite]? = nil, + catallactic: [Catallactic]? = nil, + cemental: [Cemental]? = nil, + chytridiaceae: [ChytridiaceaeElement]? = nil, + discordia: [DiscordiaElement]? = nil, + endomyces: [Endomyce]? = nil, + epinephelidae: [Epinephelidae]? = nil, + eupatorium: [Eupatorium]? = nil, + gryphosaurus: [GryphosaurusElement]? = nil, + koryak: [Koryak]? = nil, + lavinia: [LaviniaElement]? = nil, + oskar: [OskarElement]? = nil, + rebecca: [RebeccaElement]? = nil, + rhomboganoidei: [Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [Ruellia]? = nil, + school: [School]? = nil, + shakespearolater: [Shakespearolater]? = nil, + svan: [Double]? = nil, + wayao: [String: Double]? = nil + ) -> TopLevel { + return TopLevel( + abranchiata: abranchiata ?? self.abranchiata, + academe: academe ?? self.academe, + acquirable: acquirable ?? self.acquirable, + aerometry: aerometry ?? self.aerometry, + alexin: alexin ?? self.alexin, + alleviate: alleviate ?? self.alleviate, + amaas: amaas ?? self.amaas, + ambassage: ambassage ?? self.ambassage, + amphithyron: amphithyron ?? self.amphithyron, + andriana: andriana ?? self.andriana, + ankee: ankee ?? self.ankee, + annihilator: annihilator ?? self.annihilator, + annulose: annulose ?? self.annulose, + ansarie: ansarie ?? self.ansarie, + aphasia: aphasia ?? self.aphasia, + asprawl: asprawl ?? self.asprawl, + attractive: attractive ?? self.attractive, + barksome: barksome ?? self.barksome, + bedesman: bedesman ?? self.bedesman, + belard: belard ?? self.belard, + bocking: bocking ?? self.bocking, + brawlingly: brawlingly ?? self.brawlingly, + brookie: brookie ?? self.brookie, + bumboatman: bumboatman ?? self.bumboatman, + bystreet: bystreet ?? self.bystreet, + calaverite: calaverite ?? self.calaverite, + catallactic: catallactic ?? self.catallactic, + cemental: cemental ?? self.cemental, + chytridiaceae: chytridiaceae ?? self.chytridiaceae, + discordia: discordia ?? self.discordia, + endomyces: endomyces ?? self.endomyces, + epinephelidae: epinephelidae ?? self.epinephelidae, + eupatorium: eupatorium ?? self.eupatorium, + gryphosaurus: gryphosaurus ?? self.gryphosaurus, + koryak: koryak ?? self.koryak, + lavinia: lavinia ?? self.lavinia, + oskar: oskar ?? self.oskar, + rebecca: rebecca ?? self.rebecca, + rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei, + rigsmal: rigsmal ?? self.rigsmal, + ruellia: ruellia ?? self.ruellia, + school: school ?? self.school, + shakespearolater: shakespearolater ?? self.shakespearolater, + svan: svan ?? self.svan, + wayao: wayao ?? self.wayao + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Abranchiata: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Academe: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Acquirable: Codable, Sendable { + case integerMap([String: Int]) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Aerometry: Codable, Sendable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Alexin: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum AlleviateElement: Codable, Sendable { + case alleviateClass(AlleviateClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(AlleviateClass.self) { + self = .alleviateClass(x) + return + } + throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .alleviateClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +// MARK: - AlleviateClass +struct AlleviateClass: Codable, Sendable { + let apriori: JSONNull? + let beggarer: JSONNull? + let brokenheartedly: JSONNull? + let debilitation: JSONNull? + let frike: JSONNull? + let gastrolith: JSONNull? + let hulsean: JSONNull? + let orthocentric: JSONNull? + let petaly: JSONNull? + let probudgeting: JSONNull? + let reacquire: JSONNull? + let scow: JSONNull? + let shutoff: JSONNull? + let subcontiguous: JSONNull? + let suffumigate: JSONNull? + let transformable: JSONNull? + let uncoroneted: JSONNull? + let unparking: JSONNull? + let unvarnishedness: JSONNull? + let wherewithal: JSONNull? + + enum CodingKeys: String, CodingKey { + case apriori = "apriori" + case beggarer = "beggarer" + case brokenheartedly = "brokenheartedly" + case debilitation = "debilitation" + case frike = "frike" + case gastrolith = "gastrolith" + case hulsean = "Hulsean" + case orthocentric = "orthocentric" + case petaly = "petaly" + case probudgeting = "probudgeting" + case reacquire = "reacquire" + case scow = "scow" + case shutoff = "shutoff" + case subcontiguous = "subcontiguous" + case suffumigate = "suffumigate" + case transformable = "transformable" + case uncoroneted = "uncoroneted" + case unparking = "unparking" + case unvarnishedness = "unvarnishedness" + case wherewithal = "wherewithal" + } +} + +// MARK: AlleviateClass convenience initializers and mutators + +extension AlleviateClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(AlleviateClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apriori: JSONNull?? = nil, + beggarer: JSONNull?? = nil, + brokenheartedly: JSONNull?? = nil, + debilitation: JSONNull?? = nil, + frike: JSONNull?? = nil, + gastrolith: JSONNull?? = nil, + hulsean: JSONNull?? = nil, + orthocentric: JSONNull?? = nil, + petaly: JSONNull?? = nil, + probudgeting: JSONNull?? = nil, + reacquire: JSONNull?? = nil, + scow: JSONNull?? = nil, + shutoff: JSONNull?? = nil, + subcontiguous: JSONNull?? = nil, + suffumigate: JSONNull?? = nil, + transformable: JSONNull?? = nil, + uncoroneted: JSONNull?? = nil, + unparking: JSONNull?? = nil, + unvarnishedness: JSONNull?? = nil, + wherewithal: JSONNull?? = nil + ) -> AlleviateClass { + return AlleviateClass( + apriori: apriori ?? self.apriori, + beggarer: beggarer ?? self.beggarer, + brokenheartedly: brokenheartedly ?? self.brokenheartedly, + debilitation: debilitation ?? self.debilitation, + frike: frike ?? self.frike, + gastrolith: gastrolith ?? self.gastrolith, + hulsean: hulsean ?? self.hulsean, + orthocentric: orthocentric ?? self.orthocentric, + petaly: petaly ?? self.petaly, + probudgeting: probudgeting ?? self.probudgeting, + reacquire: reacquire ?? self.reacquire, + scow: scow ?? self.scow, + shutoff: shutoff ?? self.shutoff, + subcontiguous: subcontiguous ?? self.subcontiguous, + suffumigate: suffumigate ?? self.suffumigate, + transformable: transformable ?? self.transformable, + uncoroneted: uncoroneted ?? self.uncoroneted, + unparking: unparking ?? self.unparking, + unvarnishedness: unvarnishedness ?? self.unvarnishedness, + wherewithal: wherewithal ?? self.wherewithal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Amaa: Codable, Sendable { + case bool(Bool) + case integer(Int) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +// MARK: - Rebecca +struct Rebecca: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: Rebecca convenience initializers and mutators + +extension Rebecca { + init(data: Data) throws { + self = try newJSONDecoder().decode(Rebecca.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> Rebecca { + return Rebecca( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Ambassage: Codable, Sendable { + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Amphithyron +struct Amphithyron: Codable, Sendable { + let akroasis: Int? + let antiphonical: Int? + let basebred: Int? + let catharticalness: Double? + let chirotherium: Int? + let conductometric: Int? + let disdiapason: String? + let ensilation: Int? + let eyebolt: Int? + let fistulated: Int? + let heteropod: Int? + let homocerc: Bool? + let juniperus: Int? + let labyrinthically: Int? + let martyrization: Int? + let mispolicy: Int? + let multipara: Int? + let nazirite: Int? + let nonbookish: JSONNull? + let possessorial: Int? + let shamed: Int? + let shelfworn: Int? + let stagnum: Int? + let those: Int? + let undecimal: Int? + + enum CodingKeys: String, CodingKey { + case akroasis = "akroasis" + case antiphonical = "antiphonical" + case basebred = "basebred" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case conductometric = "conductometric" + case disdiapason = "disdiapason" + case ensilation = "ensilation" + case eyebolt = "eyebolt" + case fistulated = "fistulated" + case heteropod = "heteropod" + case homocerc = "homocerc" + case juniperus = "Juniperus" + case labyrinthically = "labyrinthically" + case martyrization = "martyrization" + case mispolicy = "mispolicy" + case multipara = "multipara" + case nazirite = "Nazirite" + case nonbookish = "nonbookish" + case possessorial = "possessorial" + case shamed = "shamed" + case shelfworn = "shelfworn" + case stagnum = "stagnum" + case those = "Those" + case undecimal = "undecimal" + } +} + +// MARK: Amphithyron convenience initializers and mutators + +extension Amphithyron { + init(data: Data) throws { + self = try newJSONDecoder().decode(Amphithyron.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + akroasis: Int?? = nil, + antiphonical: Int?? = nil, + basebred: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + conductometric: Int?? = nil, + disdiapason: String?? = nil, + ensilation: Int?? = nil, + eyebolt: Int?? = nil, + fistulated: Int?? = nil, + heteropod: Int?? = nil, + homocerc: Bool?? = nil, + juniperus: Int?? = nil, + labyrinthically: Int?? = nil, + martyrization: Int?? = nil, + mispolicy: Int?? = nil, + multipara: Int?? = nil, + nazirite: Int?? = nil, + nonbookish: JSONNull?? = nil, + possessorial: Int?? = nil, + shamed: Int?? = nil, + shelfworn: Int?? = nil, + stagnum: Int?? = nil, + those: Int?? = nil, + undecimal: Int?? = nil + ) -> Amphithyron { + return Amphithyron( + akroasis: akroasis ?? self.akroasis, + antiphonical: antiphonical ?? self.antiphonical, + basebred: basebred ?? self.basebred, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + conductometric: conductometric ?? self.conductometric, + disdiapason: disdiapason ?? self.disdiapason, + ensilation: ensilation ?? self.ensilation, + eyebolt: eyebolt ?? self.eyebolt, + fistulated: fistulated ?? self.fistulated, + heteropod: heteropod ?? self.heteropod, + homocerc: homocerc ?? self.homocerc, + juniperus: juniperus ?? self.juniperus, + labyrinthically: labyrinthically ?? self.labyrinthically, + martyrization: martyrization ?? self.martyrization, + mispolicy: mispolicy ?? self.mispolicy, + multipara: multipara ?? self.multipara, + nazirite: nazirite ?? self.nazirite, + nonbookish: nonbookish ?? self.nonbookish, + possessorial: possessorial ?? self.possessorial, + shamed: shamed ?? self.shamed, + shelfworn: shelfworn ?? self.shelfworn, + stagnum: stagnum ?? self.stagnum, + those: those ?? self.those, + undecimal: undecimal ?? self.undecimal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnkeeElement: Codable, Sendable { + case ankeeClass(AnkeeClass) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnkeeClass.self) { + self = .ankeeClass(x) + return + } + throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ankeeClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - AnkeeClass +struct AnkeeClass: Codable, Sendable { + let anomoean: JSONNull? + let barleyhood: JSONNull? + let befriender: JSONNull? + let brutishness: JSONNull? + let cephalalgy: JSONNull? + let cirurgian: JSONNull? + let conventionally: JSONNull? + let jackshay: JSONNull? + let milammeter: JSONNull? + let naja: JSONNull? + let ombrological: JSONNull? + let phonasthenia: JSONNull? + let retrievableness: JSONNull? + let snakily: JSONNull? + let swot: JSONNull? + let tartlet: JSONNull? + let thiofuran: JSONNull? + let tracheophone: JSONNull? + let tuglike: JSONNull? + let unscratchingly: JSONNull? + + enum CodingKeys: String, CodingKey { + case anomoean = "Anomoean" + case barleyhood = "barleyhood" + case befriender = "befriender" + case brutishness = "brutishness" + case cephalalgy = "cephalalgy" + case cirurgian = "cirurgian" + case conventionally = "conventionally" + case jackshay = "jackshay" + case milammeter = "milammeter" + case naja = "Naja" + case ombrological = "ombrological" + case phonasthenia = "phonasthenia" + case retrievableness = "retrievableness" + case snakily = "snakily" + case swot = "swot" + case tartlet = "tartlet" + case thiofuran = "thiofuran" + case tracheophone = "tracheophone" + case tuglike = "tuglike" + case unscratchingly = "unscratchingly" + } +} + +// MARK: AnkeeClass convenience initializers and mutators + +extension AnkeeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(AnkeeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + anomoean: JSONNull?? = nil, + barleyhood: JSONNull?? = nil, + befriender: JSONNull?? = nil, + brutishness: JSONNull?? = nil, + cephalalgy: JSONNull?? = nil, + cirurgian: JSONNull?? = nil, + conventionally: JSONNull?? = nil, + jackshay: JSONNull?? = nil, + milammeter: JSONNull?? = nil, + naja: JSONNull?? = nil, + ombrological: JSONNull?? = nil, + phonasthenia: JSONNull?? = nil, + retrievableness: JSONNull?? = nil, + snakily: JSONNull?? = nil, + swot: JSONNull?? = nil, + tartlet: JSONNull?? = nil, + thiofuran: JSONNull?? = nil, + tracheophone: JSONNull?? = nil, + tuglike: JSONNull?? = nil, + unscratchingly: JSONNull?? = nil + ) -> AnkeeClass { + return AnkeeClass( + anomoean: anomoean ?? self.anomoean, + barleyhood: barleyhood ?? self.barleyhood, + befriender: befriender ?? self.befriender, + brutishness: brutishness ?? self.brutishness, + cephalalgy: cephalalgy ?? self.cephalalgy, + cirurgian: cirurgian ?? self.cirurgian, + conventionally: conventionally ?? self.conventionally, + jackshay: jackshay ?? self.jackshay, + milammeter: milammeter ?? self.milammeter, + naja: naja ?? self.naja, + ombrological: ombrological ?? self.ombrological, + phonasthenia: phonasthenia ?? self.phonasthenia, + retrievableness: retrievableness ?? self.retrievableness, + snakily: snakily ?? self.snakily, + swot: swot ?? self.swot, + tartlet: tartlet ?? self.tartlet, + thiofuran: thiofuran ?? self.thiofuran, + tracheophone: tracheophone ?? self.tracheophone, + tuglike: tuglike ?? self.tuglike, + unscratchingly: unscratchingly ?? self.unscratchingly + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnsarieElement: Codable, Sendable { + case ansarieClass(AnsarieClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnsarieClass.self) { + self = .ansarieClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ansarieClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - AnsarieClass +struct AnsarieClass: Codable, Sendable { + let accension: JSONNull? + let alida: JSONNull? + let asteria: JSONNull? + let beriberic: JSONNull? + let edgebone: JSONNull? + let gastrodialysis: JSONNull? + let geographic: JSONNull? + let ictonyx: JSONNull? + let metrocele: JSONNull? + let misgraft: JSONNull? + let monteith: JSONNull? + let notcher: JSONNull? + let prorestriction: JSONNull? + let ramist: JSONNull? + let throatlet: JSONNull? + let unfair: JSONNull? + let unsynonymous: JSONNull? + let water: JSONNull? + let zestfully: JSONNull? + let zincic: JSONNull? + + enum CodingKeys: String, CodingKey { + case accension = "accension" + case alida = "Alida" + case asteria = "asteria" + case beriberic = "beriberic" + case edgebone = "edgebone" + case gastrodialysis = "gastrodialysis" + case geographic = "geographic" + case ictonyx = "Ictonyx" + case metrocele = "metrocele" + case misgraft = "misgraft" + case monteith = "monteith" + case notcher = "notcher" + case prorestriction = "prorestriction" + case ramist = "Ramist" + case throatlet = "throatlet" + case unfair = "unfair" + case unsynonymous = "unsynonymous" + case water = "water" + case zestfully = "zestfully" + case zincic = "zincic" + } +} + +// MARK: AnsarieClass convenience initializers and mutators + +extension AnsarieClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(AnsarieClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accension: JSONNull?? = nil, + alida: JSONNull?? = nil, + asteria: JSONNull?? = nil, + beriberic: JSONNull?? = nil, + edgebone: JSONNull?? = nil, + gastrodialysis: JSONNull?? = nil, + geographic: JSONNull?? = nil, + ictonyx: JSONNull?? = nil, + metrocele: JSONNull?? = nil, + misgraft: JSONNull?? = nil, + monteith: JSONNull?? = nil, + notcher: JSONNull?? = nil, + prorestriction: JSONNull?? = nil, + ramist: JSONNull?? = nil, + throatlet: JSONNull?? = nil, + unfair: JSONNull?? = nil, + unsynonymous: JSONNull?? = nil, + water: JSONNull?? = nil, + zestfully: JSONNull?? = nil, + zincic: JSONNull?? = nil + ) -> AnsarieClass { + return AnsarieClass( + accension: accension ?? self.accension, + alida: alida ?? self.alida, + asteria: asteria ?? self.asteria, + beriberic: beriberic ?? self.beriberic, + edgebone: edgebone ?? self.edgebone, + gastrodialysis: gastrodialysis ?? self.gastrodialysis, + geographic: geographic ?? self.geographic, + ictonyx: ictonyx ?? self.ictonyx, + metrocele: metrocele ?? self.metrocele, + misgraft: misgraft ?? self.misgraft, + monteith: monteith ?? self.monteith, + notcher: notcher ?? self.notcher, + prorestriction: prorestriction ?? self.prorestriction, + ramist: ramist ?? self.ramist, + throatlet: throatlet ?? self.throatlet, + unfair: unfair ?? self.unfair, + unsynonymous: unsynonymous ?? self.unsynonymous, + water: water ?? self.water, + zestfully: zestfully ?? self.zestfully, + zincic: zincic ?? self.zincic + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Aphasia: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Asprawl: Codable, Sendable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Bedesman: Codable, Sendable { + case bool(Bool) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Belard: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bocking: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Brawlingly: Codable, Sendable { + case nullArray([JSONNull?]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Brookie: Codable, Sendable { + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bumboatman: Codable, Sendable { + case nullArray([JSONNull?]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Calaverite: Codable, Sendable { + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Catallactic: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Cemental: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum ChytridiaceaeElement: Codable, Sendable { + case bool(Bool) + case chytridiaceaeClass(ChytridiaceaeClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(ChytridiaceaeClass.self) { + self = .chytridiaceaeClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .chytridiaceaeClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - ChytridiaceaeClass +struct ChytridiaceaeClass: Codable, Sendable { + let batidaceae: JSONNull? + let brechites: JSONNull? + let codespairer: JSONNull? + let emery: JSONNull? + let enervative: JSONNull? + let excriminate: JSONNull? + let goshenite: JSONNull? + let grime: JSONNull? + let gritten: JSONNull? + let hectorly: JSONNull? + let intermediation: JSONNull? + let meeterly: JSONNull? + let narraganset: JSONNull? + let onymatic: JSONNull? + let paddlecock: JSONNull? + let thana: JSONNull? + let thornily: JSONNull? + let uckia: JSONNull? + let unmettle: JSONNull? + let vorticellid: JSONNull? + + enum CodingKeys: String, CodingKey { + case batidaceae = "Batidaceae" + case brechites = "Brechites" + case codespairer = "codespairer" + case emery = "Emery" + case enervative = "enervative" + case excriminate = "excriminate" + case goshenite = "goshenite" + case grime = "grime" + case gritten = "gritten" + case hectorly = "hectorly" + case intermediation = "intermediation" + case meeterly = "meeterly" + case narraganset = "Narraganset" + case onymatic = "onymatic" + case paddlecock = "paddlecock" + case thana = "thana" + case thornily = "thornily" + case uckia = "uckia" + case unmettle = "unmettle" + case vorticellid = "vorticellid" + } +} + +// MARK: ChytridiaceaeClass convenience initializers and mutators + +extension ChytridiaceaeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + batidaceae: JSONNull?? = nil, + brechites: JSONNull?? = nil, + codespairer: JSONNull?? = nil, + emery: JSONNull?? = nil, + enervative: JSONNull?? = nil, + excriminate: JSONNull?? = nil, + goshenite: JSONNull?? = nil, + grime: JSONNull?? = nil, + gritten: JSONNull?? = nil, + hectorly: JSONNull?? = nil, + intermediation: JSONNull?? = nil, + meeterly: JSONNull?? = nil, + narraganset: JSONNull?? = nil, + onymatic: JSONNull?? = nil, + paddlecock: JSONNull?? = nil, + thana: JSONNull?? = nil, + thornily: JSONNull?? = nil, + uckia: JSONNull?? = nil, + unmettle: JSONNull?? = nil, + vorticellid: JSONNull?? = nil + ) -> ChytridiaceaeClass { + return ChytridiaceaeClass( + batidaceae: batidaceae ?? self.batidaceae, + brechites: brechites ?? self.brechites, + codespairer: codespairer ?? self.codespairer, + emery: emery ?? self.emery, + enervative: enervative ?? self.enervative, + excriminate: excriminate ?? self.excriminate, + goshenite: goshenite ?? self.goshenite, + grime: grime ?? self.grime, + gritten: gritten ?? self.gritten, + hectorly: hectorly ?? self.hectorly, + intermediation: intermediation ?? self.intermediation, + meeterly: meeterly ?? self.meeterly, + narraganset: narraganset ?? self.narraganset, + onymatic: onymatic ?? self.onymatic, + paddlecock: paddlecock ?? self.paddlecock, + thana: thana ?? self.thana, + thornily: thornily ?? self.thornily, + uckia: uckia ?? self.uckia, + unmettle: unmettle ?? self.unmettle, + vorticellid: vorticellid ?? self.vorticellid + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiscordiaElement: Codable, Sendable { + case discordiaClass(DiscordiaClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiscordiaClass.self) { + self = .discordiaClass(x) + return + } + throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .discordiaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiscordiaClass +struct DiscordiaClass: Codable, Sendable { + let altaic: Int? + let amoristic: Int? + let blennophthalmia: Int? + let catharticalness: Double? + let chirotherium: Int? + let disciplinability: Int? + let disdiapason: String? + let goofer: Int? + let homocerc: Bool? + let laryngograph: Int? + let leucitis: Int? + let lymphocyst: Int? + let microcosmology: Int? + let nauseation: Int? + let nonbookish: JSONNull? + let patarin: Int? + let preliberal: Int? + let prettifier: Int? + let rangework: Int? + let redient: Int? + let subfusiform: Int? + let suicidical: Int? + let swow: Int? + let wastrel: Int? + let wingle: Int? + + enum CodingKeys: String, CodingKey { + case altaic = "Altaic" + case amoristic = "amoristic" + case blennophthalmia = "blennophthalmia" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disciplinability = "disciplinability" + case disdiapason = "disdiapason" + case goofer = "goofer" + case homocerc = "homocerc" + case laryngograph = "laryngograph" + case leucitis = "leucitis" + case lymphocyst = "lymphocyst" + case microcosmology = "microcosmology" + case nauseation = "nauseation" + case nonbookish = "nonbookish" + case patarin = "Patarin" + case preliberal = "preliberal" + case prettifier = "prettifier" + case rangework = "rangework" + case redient = "redient" + case subfusiform = "subfusiform" + case suicidical = "suicidical" + case swow = "swow" + case wastrel = "wastrel" + case wingle = "wingle" + } +} + +// MARK: DiscordiaClass convenience initializers and mutators + +extension DiscordiaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(DiscordiaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + altaic: Int?? = nil, + amoristic: Int?? = nil, + blennophthalmia: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disciplinability: Int?? = nil, + disdiapason: String?? = nil, + goofer: Int?? = nil, + homocerc: Bool?? = nil, + laryngograph: Int?? = nil, + leucitis: Int?? = nil, + lymphocyst: Int?? = nil, + microcosmology: Int?? = nil, + nauseation: Int?? = nil, + nonbookish: JSONNull?? = nil, + patarin: Int?? = nil, + preliberal: Int?? = nil, + prettifier: Int?? = nil, + rangework: Int?? = nil, + redient: Int?? = nil, + subfusiform: Int?? = nil, + suicidical: Int?? = nil, + swow: Int?? = nil, + wastrel: Int?? = nil, + wingle: Int?? = nil + ) -> DiscordiaClass { + return DiscordiaClass( + altaic: altaic ?? self.altaic, + amoristic: amoristic ?? self.amoristic, + blennophthalmia: blennophthalmia ?? self.blennophthalmia, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disciplinability: disciplinability ?? self.disciplinability, + disdiapason: disdiapason ?? self.disdiapason, + goofer: goofer ?? self.goofer, + homocerc: homocerc ?? self.homocerc, + laryngograph: laryngograph ?? self.laryngograph, + leucitis: leucitis ?? self.leucitis, + lymphocyst: lymphocyst ?? self.lymphocyst, + microcosmology: microcosmology ?? self.microcosmology, + nauseation: nauseation ?? self.nauseation, + nonbookish: nonbookish ?? self.nonbookish, + patarin: patarin ?? self.patarin, + preliberal: preliberal ?? self.preliberal, + prettifier: prettifier ?? self.prettifier, + rangework: rangework ?? self.rangework, + redient: redient ?? self.redient, + subfusiform: subfusiform ?? self.subfusiform, + suicidical: suicidical ?? self.suicidical, + swow: swow ?? self.swow, + wastrel: wastrel ?? self.wastrel, + wingle: wingle ?? self.wingle + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Endomyce: Codable, Sendable { + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Epinephelidae: Codable, Sendable { + case bool(Bool) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eupatorium: Codable, Sendable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum GryphosaurusElement: Codable, Sendable { + case gryphosaurusClass(GryphosaurusClass) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(GryphosaurusClass.self) { + self = .gryphosaurusClass(x) + return + } + throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .gryphosaurusClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - GryphosaurusClass +struct GryphosaurusClass: Codable, Sendable { + let amissibility: JSONNull? + let burushaski: JSONNull? + let citronin: JSONNull? + let coplaintiff: JSONNull? + let disquisitionary: JSONNull? + let enoplan: JSONNull? + let faintness: JSONNull? + let hebetomy: JSONNull? + let islandry: JSONNull? + let lameduck: JSONNull? + let overbattle: JSONNull? + let overinterested: JSONNull? + let phrenologic: JSONNull? + let rainband: JSONNull? + let shiningly: JSONNull? + let stamineous: JSONNull? + let subscapularis: JSONNull? + let tahami: JSONNull? + let undaubed: JSONNull? + let underntime: JSONNull? + + enum CodingKeys: String, CodingKey { + case amissibility = "amissibility" + case burushaski = "Burushaski" + case citronin = "citronin" + case coplaintiff = "coplaintiff" + case disquisitionary = "disquisitionary" + case enoplan = "enoplan" + case faintness = "faintness" + case hebetomy = "hebetomy" + case islandry = "islandry" + case lameduck = "lameduck" + case overbattle = "overbattle" + case overinterested = "overinterested" + case phrenologic = "phrenologic" + case rainband = "rainband" + case shiningly = "shiningly" + case stamineous = "stamineous" + case subscapularis = "subscapularis" + case tahami = "Tahami" + case undaubed = "undaubed" + case underntime = "underntime" + } +} + +// MARK: GryphosaurusClass convenience initializers and mutators + +extension GryphosaurusClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(GryphosaurusClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amissibility: JSONNull?? = nil, + burushaski: JSONNull?? = nil, + citronin: JSONNull?? = nil, + coplaintiff: JSONNull?? = nil, + disquisitionary: JSONNull?? = nil, + enoplan: JSONNull?? = nil, + faintness: JSONNull?? = nil, + hebetomy: JSONNull?? = nil, + islandry: JSONNull?? = nil, + lameduck: JSONNull?? = nil, + overbattle: JSONNull?? = nil, + overinterested: JSONNull?? = nil, + phrenologic: JSONNull?? = nil, + rainband: JSONNull?? = nil, + shiningly: JSONNull?? = nil, + stamineous: JSONNull?? = nil, + subscapularis: JSONNull?? = nil, + tahami: JSONNull?? = nil, + undaubed: JSONNull?? = nil, + underntime: JSONNull?? = nil + ) -> GryphosaurusClass { + return GryphosaurusClass( + amissibility: amissibility ?? self.amissibility, + burushaski: burushaski ?? self.burushaski, + citronin: citronin ?? self.citronin, + coplaintiff: coplaintiff ?? self.coplaintiff, + disquisitionary: disquisitionary ?? self.disquisitionary, + enoplan: enoplan ?? self.enoplan, + faintness: faintness ?? self.faintness, + hebetomy: hebetomy ?? self.hebetomy, + islandry: islandry ?? self.islandry, + lameduck: lameduck ?? self.lameduck, + overbattle: overbattle ?? self.overbattle, + overinterested: overinterested ?? self.overinterested, + phrenologic: phrenologic ?? self.phrenologic, + rainband: rainband ?? self.rainband, + shiningly: shiningly ?? self.shiningly, + stamineous: stamineous ?? self.stamineous, + subscapularis: subscapularis ?? self.subscapularis, + tahami: tahami ?? self.tahami, + undaubed: undaubed ?? self.undaubed, + underntime: underntime ?? self.underntime + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Koryak: Codable, Sendable { + case string(String) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum LaviniaElement: Codable, Sendable { + case laviniaClass(LaviniaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LaviniaClass.self) { + self = .laviniaClass(x) + return + } + throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .laviniaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - LaviniaClass +struct LaviniaClass: Codable, Sendable { + let agitable: Int? + let asininity: Int? + let benefiter: Int? + let bronzelike: Int? + let catharticalness: Double? + let chirotherium: Int? + let cholesteatomatous: Int? + let deprivement: Int? + let disdiapason: String? + let flippantness: Int? + let fogproof: Int? + let homocerc: Bool? + let merrymeeting: Int? + let nonbookish: JSONNull? + let overcareful: Int? + let panaris: Int? + let preacceptance: Int? + let quinoxaline: Int? + let sig: Int? + let superconfusion: Int? + let tacana: Int? + let tillotter: Int? + let tranquillize: Int? + let unquestionable: Int? + let uproute: Int? + + enum CodingKeys: String, CodingKey { + case agitable = "agitable" + case asininity = "asininity" + case benefiter = "benefiter" + case bronzelike = "bronzelike" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cholesteatomatous = "cholesteatomatous" + case deprivement = "deprivement" + case disdiapason = "disdiapason" + case flippantness = "flippantness" + case fogproof = "fogproof" + case homocerc = "homocerc" + case merrymeeting = "merrymeeting" + case nonbookish = "nonbookish" + case overcareful = "overcareful" + case panaris = "panaris" + case preacceptance = "preacceptance" + case quinoxaline = "quinoxaline" + case sig = "sig" + case superconfusion = "superconfusion" + case tacana = "Tacana" + case tillotter = "tillotter" + case tranquillize = "tranquillize" + case unquestionable = "unquestionable" + case uproute = "uproute" + } +} + +// MARK: LaviniaClass convenience initializers and mutators + +extension LaviniaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LaviniaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + agitable: Int?? = nil, + asininity: Int?? = nil, + benefiter: Int?? = nil, + bronzelike: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cholesteatomatous: Int?? = nil, + deprivement: Int?? = nil, + disdiapason: String?? = nil, + flippantness: Int?? = nil, + fogproof: Int?? = nil, + homocerc: Bool?? = nil, + merrymeeting: Int?? = nil, + nonbookish: JSONNull?? = nil, + overcareful: Int?? = nil, + panaris: Int?? = nil, + preacceptance: Int?? = nil, + quinoxaline: Int?? = nil, + sig: Int?? = nil, + superconfusion: Int?? = nil, + tacana: Int?? = nil, + tillotter: Int?? = nil, + tranquillize: Int?? = nil, + unquestionable: Int?? = nil, + uproute: Int?? = nil + ) -> LaviniaClass { + return LaviniaClass( + agitable: agitable ?? self.agitable, + asininity: asininity ?? self.asininity, + benefiter: benefiter ?? self.benefiter, + bronzelike: bronzelike ?? self.bronzelike, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous, + deprivement: deprivement ?? self.deprivement, + disdiapason: disdiapason ?? self.disdiapason, + flippantness: flippantness ?? self.flippantness, + fogproof: fogproof ?? self.fogproof, + homocerc: homocerc ?? self.homocerc, + merrymeeting: merrymeeting ?? self.merrymeeting, + nonbookish: nonbookish ?? self.nonbookish, + overcareful: overcareful ?? self.overcareful, + panaris: panaris ?? self.panaris, + preacceptance: preacceptance ?? self.preacceptance, + quinoxaline: quinoxaline ?? self.quinoxaline, + sig: sig ?? self.sig, + superconfusion: superconfusion ?? self.superconfusion, + tacana: tacana ?? self.tacana, + tillotter: tillotter ?? self.tillotter, + tranquillize: tranquillize ?? self.tranquillize, + unquestionable: unquestionable ?? self.unquestionable, + uproute: uproute ?? self.uproute + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OskarElement: Codable, Sendable { + case integerArray([Int]) + case oskarClass(OskarClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(OskarClass.self) { + self = .oskarClass(x) + return + } + throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .oskarClass(let x): + try container.encode(x) + } + } +} + +// MARK: - OskarClass +struct OskarClass: Codable, Sendable { + let acrobates: JSONNull? + let beanshooter: JSONNull? + let bearhound: JSONNull? + let cayuga: JSONNull? + let guarneri: JSONNull? + let hypochondriacism: JSONNull? + let indication: JSONNull? + let jaculative: JSONNull? + let nagana: JSONNull? + let netherlandish: JSONNull? + let noctivagous: JSONNull? + let nonphysiological: JSONNull? + let praxis: JSONNull? + let provision: JSONNull? + let subterhuman: JSONNull? + let sunlit: JSONNull? + let syncraniate: JSONNull? + let teachment: JSONNull? + let unmutinous: JSONNull? + let unstoppable: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrobates = "Acrobates" + case beanshooter = "beanshooter" + case bearhound = "bearhound" + case cayuga = "Cayuga" + case guarneri = "guarneri" + case hypochondriacism = "hypochondriacism" + case indication = "indication" + case jaculative = "jaculative" + case nagana = "nagana" + case netherlandish = "Netherlandish" + case noctivagous = "noctivagous" + case nonphysiological = "nonphysiological" + case praxis = "praxis" + case provision = "provision" + case subterhuman = "subterhuman" + case sunlit = "sunlit" + case syncraniate = "syncraniate" + case teachment = "teachment" + case unmutinous = "unmutinous" + case unstoppable = "unstoppable" + } +} + +// MARK: OskarClass convenience initializers and mutators + +extension OskarClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(OskarClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrobates: JSONNull?? = nil, + beanshooter: JSONNull?? = nil, + bearhound: JSONNull?? = nil, + cayuga: JSONNull?? = nil, + guarneri: JSONNull?? = nil, + hypochondriacism: JSONNull?? = nil, + indication: JSONNull?? = nil, + jaculative: JSONNull?? = nil, + nagana: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + noctivagous: JSONNull?? = nil, + nonphysiological: JSONNull?? = nil, + praxis: JSONNull?? = nil, + provision: JSONNull?? = nil, + subterhuman: JSONNull?? = nil, + sunlit: JSONNull?? = nil, + syncraniate: JSONNull?? = nil, + teachment: JSONNull?? = nil, + unmutinous: JSONNull?? = nil, + unstoppable: JSONNull?? = nil + ) -> OskarClass { + return OskarClass( + acrobates: acrobates ?? self.acrobates, + beanshooter: beanshooter ?? self.beanshooter, + bearhound: bearhound ?? self.bearhound, + cayuga: cayuga ?? self.cayuga, + guarneri: guarneri ?? self.guarneri, + hypochondriacism: hypochondriacism ?? self.hypochondriacism, + indication: indication ?? self.indication, + jaculative: jaculative ?? self.jaculative, + nagana: nagana ?? self.nagana, + netherlandish: netherlandish ?? self.netherlandish, + noctivagous: noctivagous ?? self.noctivagous, + nonphysiological: nonphysiological ?? self.nonphysiological, + praxis: praxis ?? self.praxis, + provision: provision ?? self.provision, + subterhuman: subterhuman ?? self.subterhuman, + sunlit: sunlit ?? self.sunlit, + syncraniate: syncraniate ?? self.syncraniate, + teachment: teachment ?? self.teachment, + unmutinous: unmutinous ?? self.unmutinous, + unstoppable: unstoppable ?? self.unstoppable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum RebeccaElement: Codable, Sendable { + case integer(Int) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Rhomboganoidei: Codable, Sendable { + case integerArray([Int]) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Ruellia: Codable, Sendable { + case bool(Bool) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum School: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Shakespearolater: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations2.json/struct-or-class-class--238d6c8a12d4/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations2.json/struct-or-class-class--238d6c8a12d4/quicktype.swift new file mode 100644 index 0000000..1cbf677 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations2.json/struct-or-class-class--238d6c8a12d4/quicktype.swift @@ -0,0 +1,2891 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable, Sendable { + let abranchiata: [Abranchiata] + let academe: [Academe] + let acquirable: [Acquirable] + let aerometry: [Aerometry] + let alexin: [Alexin] + let alleviate: [AlleviateElement] + let amaas: [Amaa] + let ambassage: [Ambassage] + let amphithyron: [Amphithyron?] + let andriana: [String?] + let ankee: [AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [AnsarieElement] + let aphasia: [Aphasia] + let asprawl: [Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [Bedesman] + let belard: [Belard] + let bocking: [Bocking] + let brawlingly: [Brawlingly] + let brookie: [Brookie] + let bumboatman: [Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [Calaverite] + let catallactic: [Catallactic] + let cemental: [Cemental] + let chytridiaceae: [ChytridiaceaeElement] + let discordia: [DiscordiaElement] + let endomyces: [Endomyce] + let epinephelidae: [Epinephelidae] + let eupatorium: [Eupatorium] + let gryphosaurus: [GryphosaurusElement] + let koryak: [Koryak] + let lavinia: [LaviniaElement] + let oskar: [OskarElement] + let rebecca: [RebeccaElement] + let rhomboganoidei: [Rhomboganoidei] + let rigsmal: Bool + let ruellia: [Ruellia] + let school: [School] + let shakespearolater: [Shakespearolater] + let svan: [Double] + let wayao: [String: Double] + + enum CodingKeys: String, CodingKey { + case abranchiata = "Abranchiata" + case academe = "academe" + case acquirable = "acquirable" + case aerometry = "aerometry" + case alexin = "alexin" + case alleviate = "alleviate" + case amaas = "amaas" + case ambassage = "ambassage" + case amphithyron = "amphithyron" + case andriana = "Andriana" + case ankee = "ankee" + case annihilator = "annihilator" + case annulose = "annulose" + case ansarie = "Ansarie" + case aphasia = "aphasia" + case asprawl = "asprawl" + case attractive = "attractive" + case barksome = "barksome" + case bedesman = "bedesman" + case belard = "belard" + case bocking = "bocking" + case brawlingly = "brawlingly" + case brookie = "brookie" + case bumboatman = "bumboatman" + case bystreet = "bystreet" + case calaverite = "calaverite" + case catallactic = "catallactic" + case cemental = "cemental" + case chytridiaceae = "Chytridiaceae" + case discordia = "Discordia" + case endomyces = "Endomyces" + case epinephelidae = "Epinephelidae" + case eupatorium = "Eupatorium" + case gryphosaurus = "Gryphosaurus" + case koryak = "Koryak" + case lavinia = "Lavinia" + case oskar = "Oskar" + case rebecca = "Rebecca" + case rhomboganoidei = "Rhomboganoidei" + case rigsmal = "Rigsmal" + case ruellia = "Ruellia" + case school = "School" + case shakespearolater = "Shakespearolater" + case svan = "Svan" + case wayao = "Wayao" + } + + init(abranchiata: [Abranchiata], academe: [Academe], acquirable: [Acquirable], aerometry: [Aerometry], alexin: [Alexin], alleviate: [AlleviateElement], amaas: [Amaa], ambassage: [Ambassage], amphithyron: [Amphithyron?], andriana: [String?], ankee: [AnkeeElement], annihilator: [[String: Int?]?], annulose: JSONNull?, ansarie: [AnsarieElement], aphasia: [Aphasia], asprawl: [Asprawl], attractive: [Bool?], barksome: [String: Int], bedesman: [Bedesman], belard: [Belard], bocking: [Bocking], brawlingly: [Brawlingly], brookie: [Brookie], bumboatman: [Bumboatman], bystreet: [JSONNull?], calaverite: [Calaverite], catallactic: [Catallactic], cemental: [Cemental], chytridiaceae: [ChytridiaceaeElement], discordia: [DiscordiaElement], endomyces: [Endomyce], epinephelidae: [Epinephelidae], eupatorium: [Eupatorium], gryphosaurus: [GryphosaurusElement], koryak: [Koryak], lavinia: [LaviniaElement], oskar: [OskarElement], rebecca: [RebeccaElement], rhomboganoidei: [Rhomboganoidei], rigsmal: Bool, ruellia: [Ruellia], school: [School], shakespearolater: [Shakespearolater], svan: [Double], wayao: [String: Double]) { + self.abranchiata = abranchiata + self.academe = academe + self.acquirable = acquirable + self.aerometry = aerometry + self.alexin = alexin + self.alleviate = alleviate + self.amaas = amaas + self.ambassage = ambassage + self.amphithyron = amphithyron + self.andriana = andriana + self.ankee = ankee + self.annihilator = annihilator + self.annulose = annulose + self.ansarie = ansarie + self.aphasia = aphasia + self.asprawl = asprawl + self.attractive = attractive + self.barksome = barksome + self.bedesman = bedesman + self.belard = belard + self.bocking = bocking + self.brawlingly = brawlingly + self.brookie = brookie + self.bumboatman = bumboatman + self.bystreet = bystreet + self.calaverite = calaverite + self.catallactic = catallactic + self.cemental = cemental + self.chytridiaceae = chytridiaceae + self.discordia = discordia + self.endomyces = endomyces + self.epinephelidae = epinephelidae + self.eupatorium = eupatorium + self.gryphosaurus = gryphosaurus + self.koryak = koryak + self.lavinia = lavinia + self.oskar = oskar + self.rebecca = rebecca + self.rhomboganoidei = rhomboganoidei + self.rigsmal = rigsmal + self.ruellia = ruellia + self.school = school + self.shakespearolater = shakespearolater + self.svan = svan + self.wayao = wayao + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(abranchiata: me.abranchiata, academe: me.academe, acquirable: me.acquirable, aerometry: me.aerometry, alexin: me.alexin, alleviate: me.alleviate, amaas: me.amaas, ambassage: me.ambassage, amphithyron: me.amphithyron, andriana: me.andriana, ankee: me.ankee, annihilator: me.annihilator, annulose: me.annulose, ansarie: me.ansarie, aphasia: me.aphasia, asprawl: me.asprawl, attractive: me.attractive, barksome: me.barksome, bedesman: me.bedesman, belard: me.belard, bocking: me.bocking, brawlingly: me.brawlingly, brookie: me.brookie, bumboatman: me.bumboatman, bystreet: me.bystreet, calaverite: me.calaverite, catallactic: me.catallactic, cemental: me.cemental, chytridiaceae: me.chytridiaceae, discordia: me.discordia, endomyces: me.endomyces, epinephelidae: me.epinephelidae, eupatorium: me.eupatorium, gryphosaurus: me.gryphosaurus, koryak: me.koryak, lavinia: me.lavinia, oskar: me.oskar, rebecca: me.rebecca, rhomboganoidei: me.rhomboganoidei, rigsmal: me.rigsmal, ruellia: me.ruellia, school: me.school, shakespearolater: me.shakespearolater, svan: me.svan, wayao: me.wayao) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchiata: [Abranchiata]? = nil, + academe: [Academe]? = nil, + acquirable: [Acquirable]? = nil, + aerometry: [Aerometry]? = nil, + alexin: [Alexin]? = nil, + alleviate: [AlleviateElement]? = nil, + amaas: [Amaa]? = nil, + ambassage: [Ambassage]? = nil, + amphithyron: [Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [AnsarieElement]? = nil, + aphasia: [Aphasia]? = nil, + asprawl: [Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [Bedesman]? = nil, + belard: [Belard]? = nil, + bocking: [Bocking]? = nil, + brawlingly: [Brawlingly]? = nil, + brookie: [Brookie]? = nil, + bumboatman: [Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [Calaverite]? = nil, + catallactic: [Catallactic]? = nil, + cemental: [Cemental]? = nil, + chytridiaceae: [ChytridiaceaeElement]? = nil, + discordia: [DiscordiaElement]? = nil, + endomyces: [Endomyce]? = nil, + epinephelidae: [Epinephelidae]? = nil, + eupatorium: [Eupatorium]? = nil, + gryphosaurus: [GryphosaurusElement]? = nil, + koryak: [Koryak]? = nil, + lavinia: [LaviniaElement]? = nil, + oskar: [OskarElement]? = nil, + rebecca: [RebeccaElement]? = nil, + rhomboganoidei: [Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [Ruellia]? = nil, + school: [School]? = nil, + shakespearolater: [Shakespearolater]? = nil, + svan: [Double]? = nil, + wayao: [String: Double]? = nil + ) -> TopLevel { + return TopLevel( + abranchiata: abranchiata ?? self.abranchiata, + academe: academe ?? self.academe, + acquirable: acquirable ?? self.acquirable, + aerometry: aerometry ?? self.aerometry, + alexin: alexin ?? self.alexin, + alleviate: alleviate ?? self.alleviate, + amaas: amaas ?? self.amaas, + ambassage: ambassage ?? self.ambassage, + amphithyron: amphithyron ?? self.amphithyron, + andriana: andriana ?? self.andriana, + ankee: ankee ?? self.ankee, + annihilator: annihilator ?? self.annihilator, + annulose: annulose ?? self.annulose, + ansarie: ansarie ?? self.ansarie, + aphasia: aphasia ?? self.aphasia, + asprawl: asprawl ?? self.asprawl, + attractive: attractive ?? self.attractive, + barksome: barksome ?? self.barksome, + bedesman: bedesman ?? self.bedesman, + belard: belard ?? self.belard, + bocking: bocking ?? self.bocking, + brawlingly: brawlingly ?? self.brawlingly, + brookie: brookie ?? self.brookie, + bumboatman: bumboatman ?? self.bumboatman, + bystreet: bystreet ?? self.bystreet, + calaverite: calaverite ?? self.calaverite, + catallactic: catallactic ?? self.catallactic, + cemental: cemental ?? self.cemental, + chytridiaceae: chytridiaceae ?? self.chytridiaceae, + discordia: discordia ?? self.discordia, + endomyces: endomyces ?? self.endomyces, + epinephelidae: epinephelidae ?? self.epinephelidae, + eupatorium: eupatorium ?? self.eupatorium, + gryphosaurus: gryphosaurus ?? self.gryphosaurus, + koryak: koryak ?? self.koryak, + lavinia: lavinia ?? self.lavinia, + oskar: oskar ?? self.oskar, + rebecca: rebecca ?? self.rebecca, + rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei, + rigsmal: rigsmal ?? self.rigsmal, + ruellia: ruellia ?? self.ruellia, + school: school ?? self.school, + shakespearolater: shakespearolater ?? self.shakespearolater, + svan: svan ?? self.svan, + wayao: wayao ?? self.wayao + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Abranchiata: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Academe: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Acquirable: Codable, Sendable { + case integerMap([String: Int]) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Aerometry: Codable, Sendable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Alexin: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum AlleviateElement: Codable, Sendable { + case alleviateClass(AlleviateClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(AlleviateClass.self) { + self = .alleviateClass(x) + return + } + throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .alleviateClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +// MARK: - AlleviateClass +final class AlleviateClass: Codable, Sendable { + let apriori: JSONNull? + let beggarer: JSONNull? + let brokenheartedly: JSONNull? + let debilitation: JSONNull? + let frike: JSONNull? + let gastrolith: JSONNull? + let hulsean: JSONNull? + let orthocentric: JSONNull? + let petaly: JSONNull? + let probudgeting: JSONNull? + let reacquire: JSONNull? + let scow: JSONNull? + let shutoff: JSONNull? + let subcontiguous: JSONNull? + let suffumigate: JSONNull? + let transformable: JSONNull? + let uncoroneted: JSONNull? + let unparking: JSONNull? + let unvarnishedness: JSONNull? + let wherewithal: JSONNull? + + enum CodingKeys: String, CodingKey { + case apriori = "apriori" + case beggarer = "beggarer" + case brokenheartedly = "brokenheartedly" + case debilitation = "debilitation" + case frike = "frike" + case gastrolith = "gastrolith" + case hulsean = "Hulsean" + case orthocentric = "orthocentric" + case petaly = "petaly" + case probudgeting = "probudgeting" + case reacquire = "reacquire" + case scow = "scow" + case shutoff = "shutoff" + case subcontiguous = "subcontiguous" + case suffumigate = "suffumigate" + case transformable = "transformable" + case uncoroneted = "uncoroneted" + case unparking = "unparking" + case unvarnishedness = "unvarnishedness" + case wherewithal = "wherewithal" + } + + init(apriori: JSONNull?, beggarer: JSONNull?, brokenheartedly: JSONNull?, debilitation: JSONNull?, frike: JSONNull?, gastrolith: JSONNull?, hulsean: JSONNull?, orthocentric: JSONNull?, petaly: JSONNull?, probudgeting: JSONNull?, reacquire: JSONNull?, scow: JSONNull?, shutoff: JSONNull?, subcontiguous: JSONNull?, suffumigate: JSONNull?, transformable: JSONNull?, uncoroneted: JSONNull?, unparking: JSONNull?, unvarnishedness: JSONNull?, wherewithal: JSONNull?) { + self.apriori = apriori + self.beggarer = beggarer + self.brokenheartedly = brokenheartedly + self.debilitation = debilitation + self.frike = frike + self.gastrolith = gastrolith + self.hulsean = hulsean + self.orthocentric = orthocentric + self.petaly = petaly + self.probudgeting = probudgeting + self.reacquire = reacquire + self.scow = scow + self.shutoff = shutoff + self.subcontiguous = subcontiguous + self.suffumigate = suffumigate + self.transformable = transformable + self.uncoroneted = uncoroneted + self.unparking = unparking + self.unvarnishedness = unvarnishedness + self.wherewithal = wherewithal + } +} + +// MARK: AlleviateClass convenience initializers and mutators + +extension AlleviateClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AlleviateClass.self, from: data) + self.init(apriori: me.apriori, beggarer: me.beggarer, brokenheartedly: me.brokenheartedly, debilitation: me.debilitation, frike: me.frike, gastrolith: me.gastrolith, hulsean: me.hulsean, orthocentric: me.orthocentric, petaly: me.petaly, probudgeting: me.probudgeting, reacquire: me.reacquire, scow: me.scow, shutoff: me.shutoff, subcontiguous: me.subcontiguous, suffumigate: me.suffumigate, transformable: me.transformable, uncoroneted: me.uncoroneted, unparking: me.unparking, unvarnishedness: me.unvarnishedness, wherewithal: me.wherewithal) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apriori: JSONNull?? = nil, + beggarer: JSONNull?? = nil, + brokenheartedly: JSONNull?? = nil, + debilitation: JSONNull?? = nil, + frike: JSONNull?? = nil, + gastrolith: JSONNull?? = nil, + hulsean: JSONNull?? = nil, + orthocentric: JSONNull?? = nil, + petaly: JSONNull?? = nil, + probudgeting: JSONNull?? = nil, + reacquire: JSONNull?? = nil, + scow: JSONNull?? = nil, + shutoff: JSONNull?? = nil, + subcontiguous: JSONNull?? = nil, + suffumigate: JSONNull?? = nil, + transformable: JSONNull?? = nil, + uncoroneted: JSONNull?? = nil, + unparking: JSONNull?? = nil, + unvarnishedness: JSONNull?? = nil, + wherewithal: JSONNull?? = nil + ) -> AlleviateClass { + return AlleviateClass( + apriori: apriori ?? self.apriori, + beggarer: beggarer ?? self.beggarer, + brokenheartedly: brokenheartedly ?? self.brokenheartedly, + debilitation: debilitation ?? self.debilitation, + frike: frike ?? self.frike, + gastrolith: gastrolith ?? self.gastrolith, + hulsean: hulsean ?? self.hulsean, + orthocentric: orthocentric ?? self.orthocentric, + petaly: petaly ?? self.petaly, + probudgeting: probudgeting ?? self.probudgeting, + reacquire: reacquire ?? self.reacquire, + scow: scow ?? self.scow, + shutoff: shutoff ?? self.shutoff, + subcontiguous: subcontiguous ?? self.subcontiguous, + suffumigate: suffumigate ?? self.suffumigate, + transformable: transformable ?? self.transformable, + uncoroneted: uncoroneted ?? self.uncoroneted, + unparking: unparking ?? self.unparking, + unvarnishedness: unvarnishedness ?? self.unvarnishedness, + wherewithal: wherewithal ?? self.wherewithal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Amaa: Codable, Sendable { + case bool(Bool) + case integer(Int) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +// MARK: - Rebecca +final class Rebecca: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: Rebecca convenience initializers and mutators + +extension Rebecca { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Rebecca.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> Rebecca { + return Rebecca( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Ambassage: Codable, Sendable { + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Amphithyron +final class Amphithyron: Codable, Sendable { + let akroasis: Int? + let antiphonical: Int? + let basebred: Int? + let catharticalness: Double? + let chirotherium: Int? + let conductometric: Int? + let disdiapason: String? + let ensilation: Int? + let eyebolt: Int? + let fistulated: Int? + let heteropod: Int? + let homocerc: Bool? + let juniperus: Int? + let labyrinthically: Int? + let martyrization: Int? + let mispolicy: Int? + let multipara: Int? + let nazirite: Int? + let nonbookish: JSONNull? + let possessorial: Int? + let shamed: Int? + let shelfworn: Int? + let stagnum: Int? + let those: Int? + let undecimal: Int? + + enum CodingKeys: String, CodingKey { + case akroasis = "akroasis" + case antiphonical = "antiphonical" + case basebred = "basebred" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case conductometric = "conductometric" + case disdiapason = "disdiapason" + case ensilation = "ensilation" + case eyebolt = "eyebolt" + case fistulated = "fistulated" + case heteropod = "heteropod" + case homocerc = "homocerc" + case juniperus = "Juniperus" + case labyrinthically = "labyrinthically" + case martyrization = "martyrization" + case mispolicy = "mispolicy" + case multipara = "multipara" + case nazirite = "Nazirite" + case nonbookish = "nonbookish" + case possessorial = "possessorial" + case shamed = "shamed" + case shelfworn = "shelfworn" + case stagnum = "stagnum" + case those = "Those" + case undecimal = "undecimal" + } + + init(akroasis: Int?, antiphonical: Int?, basebred: Int?, catharticalness: Double?, chirotherium: Int?, conductometric: Int?, disdiapason: String?, ensilation: Int?, eyebolt: Int?, fistulated: Int?, heteropod: Int?, homocerc: Bool?, juniperus: Int?, labyrinthically: Int?, martyrization: Int?, mispolicy: Int?, multipara: Int?, nazirite: Int?, nonbookish: JSONNull?, possessorial: Int?, shamed: Int?, shelfworn: Int?, stagnum: Int?, those: Int?, undecimal: Int?) { + self.akroasis = akroasis + self.antiphonical = antiphonical + self.basebred = basebred + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.conductometric = conductometric + self.disdiapason = disdiapason + self.ensilation = ensilation + self.eyebolt = eyebolt + self.fistulated = fistulated + self.heteropod = heteropod + self.homocerc = homocerc + self.juniperus = juniperus + self.labyrinthically = labyrinthically + self.martyrization = martyrization + self.mispolicy = mispolicy + self.multipara = multipara + self.nazirite = nazirite + self.nonbookish = nonbookish + self.possessorial = possessorial + self.shamed = shamed + self.shelfworn = shelfworn + self.stagnum = stagnum + self.those = those + self.undecimal = undecimal + } +} + +// MARK: Amphithyron convenience initializers and mutators + +extension Amphithyron { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Amphithyron.self, from: data) + self.init(akroasis: me.akroasis, antiphonical: me.antiphonical, basebred: me.basebred, catharticalness: me.catharticalness, chirotherium: me.chirotherium, conductometric: me.conductometric, disdiapason: me.disdiapason, ensilation: me.ensilation, eyebolt: me.eyebolt, fistulated: me.fistulated, heteropod: me.heteropod, homocerc: me.homocerc, juniperus: me.juniperus, labyrinthically: me.labyrinthically, martyrization: me.martyrization, mispolicy: me.mispolicy, multipara: me.multipara, nazirite: me.nazirite, nonbookish: me.nonbookish, possessorial: me.possessorial, shamed: me.shamed, shelfworn: me.shelfworn, stagnum: me.stagnum, those: me.those, undecimal: me.undecimal) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + akroasis: Int?? = nil, + antiphonical: Int?? = nil, + basebred: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + conductometric: Int?? = nil, + disdiapason: String?? = nil, + ensilation: Int?? = nil, + eyebolt: Int?? = nil, + fistulated: Int?? = nil, + heteropod: Int?? = nil, + homocerc: Bool?? = nil, + juniperus: Int?? = nil, + labyrinthically: Int?? = nil, + martyrization: Int?? = nil, + mispolicy: Int?? = nil, + multipara: Int?? = nil, + nazirite: Int?? = nil, + nonbookish: JSONNull?? = nil, + possessorial: Int?? = nil, + shamed: Int?? = nil, + shelfworn: Int?? = nil, + stagnum: Int?? = nil, + those: Int?? = nil, + undecimal: Int?? = nil + ) -> Amphithyron { + return Amphithyron( + akroasis: akroasis ?? self.akroasis, + antiphonical: antiphonical ?? self.antiphonical, + basebred: basebred ?? self.basebred, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + conductometric: conductometric ?? self.conductometric, + disdiapason: disdiapason ?? self.disdiapason, + ensilation: ensilation ?? self.ensilation, + eyebolt: eyebolt ?? self.eyebolt, + fistulated: fistulated ?? self.fistulated, + heteropod: heteropod ?? self.heteropod, + homocerc: homocerc ?? self.homocerc, + juniperus: juniperus ?? self.juniperus, + labyrinthically: labyrinthically ?? self.labyrinthically, + martyrization: martyrization ?? self.martyrization, + mispolicy: mispolicy ?? self.mispolicy, + multipara: multipara ?? self.multipara, + nazirite: nazirite ?? self.nazirite, + nonbookish: nonbookish ?? self.nonbookish, + possessorial: possessorial ?? self.possessorial, + shamed: shamed ?? self.shamed, + shelfworn: shelfworn ?? self.shelfworn, + stagnum: stagnum ?? self.stagnum, + those: those ?? self.those, + undecimal: undecimal ?? self.undecimal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnkeeElement: Codable, Sendable { + case ankeeClass(AnkeeClass) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnkeeClass.self) { + self = .ankeeClass(x) + return + } + throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ankeeClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - AnkeeClass +final class AnkeeClass: Codable, Sendable { + let anomoean: JSONNull? + let barleyhood: JSONNull? + let befriender: JSONNull? + let brutishness: JSONNull? + let cephalalgy: JSONNull? + let cirurgian: JSONNull? + let conventionally: JSONNull? + let jackshay: JSONNull? + let milammeter: JSONNull? + let naja: JSONNull? + let ombrological: JSONNull? + let phonasthenia: JSONNull? + let retrievableness: JSONNull? + let snakily: JSONNull? + let swot: JSONNull? + let tartlet: JSONNull? + let thiofuran: JSONNull? + let tracheophone: JSONNull? + let tuglike: JSONNull? + let unscratchingly: JSONNull? + + enum CodingKeys: String, CodingKey { + case anomoean = "Anomoean" + case barleyhood = "barleyhood" + case befriender = "befriender" + case brutishness = "brutishness" + case cephalalgy = "cephalalgy" + case cirurgian = "cirurgian" + case conventionally = "conventionally" + case jackshay = "jackshay" + case milammeter = "milammeter" + case naja = "Naja" + case ombrological = "ombrological" + case phonasthenia = "phonasthenia" + case retrievableness = "retrievableness" + case snakily = "snakily" + case swot = "swot" + case tartlet = "tartlet" + case thiofuran = "thiofuran" + case tracheophone = "tracheophone" + case tuglike = "tuglike" + case unscratchingly = "unscratchingly" + } + + init(anomoean: JSONNull?, barleyhood: JSONNull?, befriender: JSONNull?, brutishness: JSONNull?, cephalalgy: JSONNull?, cirurgian: JSONNull?, conventionally: JSONNull?, jackshay: JSONNull?, milammeter: JSONNull?, naja: JSONNull?, ombrological: JSONNull?, phonasthenia: JSONNull?, retrievableness: JSONNull?, snakily: JSONNull?, swot: JSONNull?, tartlet: JSONNull?, thiofuran: JSONNull?, tracheophone: JSONNull?, tuglike: JSONNull?, unscratchingly: JSONNull?) { + self.anomoean = anomoean + self.barleyhood = barleyhood + self.befriender = befriender + self.brutishness = brutishness + self.cephalalgy = cephalalgy + self.cirurgian = cirurgian + self.conventionally = conventionally + self.jackshay = jackshay + self.milammeter = milammeter + self.naja = naja + self.ombrological = ombrological + self.phonasthenia = phonasthenia + self.retrievableness = retrievableness + self.snakily = snakily + self.swot = swot + self.tartlet = tartlet + self.thiofuran = thiofuran + self.tracheophone = tracheophone + self.tuglike = tuglike + self.unscratchingly = unscratchingly + } +} + +// MARK: AnkeeClass convenience initializers and mutators + +extension AnkeeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AnkeeClass.self, from: data) + self.init(anomoean: me.anomoean, barleyhood: me.barleyhood, befriender: me.befriender, brutishness: me.brutishness, cephalalgy: me.cephalalgy, cirurgian: me.cirurgian, conventionally: me.conventionally, jackshay: me.jackshay, milammeter: me.milammeter, naja: me.naja, ombrological: me.ombrological, phonasthenia: me.phonasthenia, retrievableness: me.retrievableness, snakily: me.snakily, swot: me.swot, tartlet: me.tartlet, thiofuran: me.thiofuran, tracheophone: me.tracheophone, tuglike: me.tuglike, unscratchingly: me.unscratchingly) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + anomoean: JSONNull?? = nil, + barleyhood: JSONNull?? = nil, + befriender: JSONNull?? = nil, + brutishness: JSONNull?? = nil, + cephalalgy: JSONNull?? = nil, + cirurgian: JSONNull?? = nil, + conventionally: JSONNull?? = nil, + jackshay: JSONNull?? = nil, + milammeter: JSONNull?? = nil, + naja: JSONNull?? = nil, + ombrological: JSONNull?? = nil, + phonasthenia: JSONNull?? = nil, + retrievableness: JSONNull?? = nil, + snakily: JSONNull?? = nil, + swot: JSONNull?? = nil, + tartlet: JSONNull?? = nil, + thiofuran: JSONNull?? = nil, + tracheophone: JSONNull?? = nil, + tuglike: JSONNull?? = nil, + unscratchingly: JSONNull?? = nil + ) -> AnkeeClass { + return AnkeeClass( + anomoean: anomoean ?? self.anomoean, + barleyhood: barleyhood ?? self.barleyhood, + befriender: befriender ?? self.befriender, + brutishness: brutishness ?? self.brutishness, + cephalalgy: cephalalgy ?? self.cephalalgy, + cirurgian: cirurgian ?? self.cirurgian, + conventionally: conventionally ?? self.conventionally, + jackshay: jackshay ?? self.jackshay, + milammeter: milammeter ?? self.milammeter, + naja: naja ?? self.naja, + ombrological: ombrological ?? self.ombrological, + phonasthenia: phonasthenia ?? self.phonasthenia, + retrievableness: retrievableness ?? self.retrievableness, + snakily: snakily ?? self.snakily, + swot: swot ?? self.swot, + tartlet: tartlet ?? self.tartlet, + thiofuran: thiofuran ?? self.thiofuran, + tracheophone: tracheophone ?? self.tracheophone, + tuglike: tuglike ?? self.tuglike, + unscratchingly: unscratchingly ?? self.unscratchingly + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnsarieElement: Codable, Sendable { + case ansarieClass(AnsarieClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnsarieClass.self) { + self = .ansarieClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ansarieClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - AnsarieClass +final class AnsarieClass: Codable, Sendable { + let accension: JSONNull? + let alida: JSONNull? + let asteria: JSONNull? + let beriberic: JSONNull? + let edgebone: JSONNull? + let gastrodialysis: JSONNull? + let geographic: JSONNull? + let ictonyx: JSONNull? + let metrocele: JSONNull? + let misgraft: JSONNull? + let monteith: JSONNull? + let notcher: JSONNull? + let prorestriction: JSONNull? + let ramist: JSONNull? + let throatlet: JSONNull? + let unfair: JSONNull? + let unsynonymous: JSONNull? + let water: JSONNull? + let zestfully: JSONNull? + let zincic: JSONNull? + + enum CodingKeys: String, CodingKey { + case accension = "accension" + case alida = "Alida" + case asteria = "asteria" + case beriberic = "beriberic" + case edgebone = "edgebone" + case gastrodialysis = "gastrodialysis" + case geographic = "geographic" + case ictonyx = "Ictonyx" + case metrocele = "metrocele" + case misgraft = "misgraft" + case monteith = "monteith" + case notcher = "notcher" + case prorestriction = "prorestriction" + case ramist = "Ramist" + case throatlet = "throatlet" + case unfair = "unfair" + case unsynonymous = "unsynonymous" + case water = "water" + case zestfully = "zestfully" + case zincic = "zincic" + } + + init(accension: JSONNull?, alida: JSONNull?, asteria: JSONNull?, beriberic: JSONNull?, edgebone: JSONNull?, gastrodialysis: JSONNull?, geographic: JSONNull?, ictonyx: JSONNull?, metrocele: JSONNull?, misgraft: JSONNull?, monteith: JSONNull?, notcher: JSONNull?, prorestriction: JSONNull?, ramist: JSONNull?, throatlet: JSONNull?, unfair: JSONNull?, unsynonymous: JSONNull?, water: JSONNull?, zestfully: JSONNull?, zincic: JSONNull?) { + self.accension = accension + self.alida = alida + self.asteria = asteria + self.beriberic = beriberic + self.edgebone = edgebone + self.gastrodialysis = gastrodialysis + self.geographic = geographic + self.ictonyx = ictonyx + self.metrocele = metrocele + self.misgraft = misgraft + self.monteith = monteith + self.notcher = notcher + self.prorestriction = prorestriction + self.ramist = ramist + self.throatlet = throatlet + self.unfair = unfair + self.unsynonymous = unsynonymous + self.water = water + self.zestfully = zestfully + self.zincic = zincic + } +} + +// MARK: AnsarieClass convenience initializers and mutators + +extension AnsarieClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AnsarieClass.self, from: data) + self.init(accension: me.accension, alida: me.alida, asteria: me.asteria, beriberic: me.beriberic, edgebone: me.edgebone, gastrodialysis: me.gastrodialysis, geographic: me.geographic, ictonyx: me.ictonyx, metrocele: me.metrocele, misgraft: me.misgraft, monteith: me.monteith, notcher: me.notcher, prorestriction: me.prorestriction, ramist: me.ramist, throatlet: me.throatlet, unfair: me.unfair, unsynonymous: me.unsynonymous, water: me.water, zestfully: me.zestfully, zincic: me.zincic) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accension: JSONNull?? = nil, + alida: JSONNull?? = nil, + asteria: JSONNull?? = nil, + beriberic: JSONNull?? = nil, + edgebone: JSONNull?? = nil, + gastrodialysis: JSONNull?? = nil, + geographic: JSONNull?? = nil, + ictonyx: JSONNull?? = nil, + metrocele: JSONNull?? = nil, + misgraft: JSONNull?? = nil, + monteith: JSONNull?? = nil, + notcher: JSONNull?? = nil, + prorestriction: JSONNull?? = nil, + ramist: JSONNull?? = nil, + throatlet: JSONNull?? = nil, + unfair: JSONNull?? = nil, + unsynonymous: JSONNull?? = nil, + water: JSONNull?? = nil, + zestfully: JSONNull?? = nil, + zincic: JSONNull?? = nil + ) -> AnsarieClass { + return AnsarieClass( + accension: accension ?? self.accension, + alida: alida ?? self.alida, + asteria: asteria ?? self.asteria, + beriberic: beriberic ?? self.beriberic, + edgebone: edgebone ?? self.edgebone, + gastrodialysis: gastrodialysis ?? self.gastrodialysis, + geographic: geographic ?? self.geographic, + ictonyx: ictonyx ?? self.ictonyx, + metrocele: metrocele ?? self.metrocele, + misgraft: misgraft ?? self.misgraft, + monteith: monteith ?? self.monteith, + notcher: notcher ?? self.notcher, + prorestriction: prorestriction ?? self.prorestriction, + ramist: ramist ?? self.ramist, + throatlet: throatlet ?? self.throatlet, + unfair: unfair ?? self.unfair, + unsynonymous: unsynonymous ?? self.unsynonymous, + water: water ?? self.water, + zestfully: zestfully ?? self.zestfully, + zincic: zincic ?? self.zincic + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Aphasia: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Asprawl: Codable, Sendable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Bedesman: Codable, Sendable { + case bool(Bool) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Belard: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bocking: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Brawlingly: Codable, Sendable { + case nullArray([JSONNull?]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Brookie: Codable, Sendable { + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bumboatman: Codable, Sendable { + case nullArray([JSONNull?]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Calaverite: Codable, Sendable { + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Catallactic: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Cemental: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum ChytridiaceaeElement: Codable, Sendable { + case bool(Bool) + case chytridiaceaeClass(ChytridiaceaeClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(ChytridiaceaeClass.self) { + self = .chytridiaceaeClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .chytridiaceaeClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - ChytridiaceaeClass +final class ChytridiaceaeClass: Codable, Sendable { + let batidaceae: JSONNull? + let brechites: JSONNull? + let codespairer: JSONNull? + let emery: JSONNull? + let enervative: JSONNull? + let excriminate: JSONNull? + let goshenite: JSONNull? + let grime: JSONNull? + let gritten: JSONNull? + let hectorly: JSONNull? + let intermediation: JSONNull? + let meeterly: JSONNull? + let narraganset: JSONNull? + let onymatic: JSONNull? + let paddlecock: JSONNull? + let thana: JSONNull? + let thornily: JSONNull? + let uckia: JSONNull? + let unmettle: JSONNull? + let vorticellid: JSONNull? + + enum CodingKeys: String, CodingKey { + case batidaceae = "Batidaceae" + case brechites = "Brechites" + case codespairer = "codespairer" + case emery = "Emery" + case enervative = "enervative" + case excriminate = "excriminate" + case goshenite = "goshenite" + case grime = "grime" + case gritten = "gritten" + case hectorly = "hectorly" + case intermediation = "intermediation" + case meeterly = "meeterly" + case narraganset = "Narraganset" + case onymatic = "onymatic" + case paddlecock = "paddlecock" + case thana = "thana" + case thornily = "thornily" + case uckia = "uckia" + case unmettle = "unmettle" + case vorticellid = "vorticellid" + } + + init(batidaceae: JSONNull?, brechites: JSONNull?, codespairer: JSONNull?, emery: JSONNull?, enervative: JSONNull?, excriminate: JSONNull?, goshenite: JSONNull?, grime: JSONNull?, gritten: JSONNull?, hectorly: JSONNull?, intermediation: JSONNull?, meeterly: JSONNull?, narraganset: JSONNull?, onymatic: JSONNull?, paddlecock: JSONNull?, thana: JSONNull?, thornily: JSONNull?, uckia: JSONNull?, unmettle: JSONNull?, vorticellid: JSONNull?) { + self.batidaceae = batidaceae + self.brechites = brechites + self.codespairer = codespairer + self.emery = emery + self.enervative = enervative + self.excriminate = excriminate + self.goshenite = goshenite + self.grime = grime + self.gritten = gritten + self.hectorly = hectorly + self.intermediation = intermediation + self.meeterly = meeterly + self.narraganset = narraganset + self.onymatic = onymatic + self.paddlecock = paddlecock + self.thana = thana + self.thornily = thornily + self.uckia = uckia + self.unmettle = unmettle + self.vorticellid = vorticellid + } +} + +// MARK: ChytridiaceaeClass convenience initializers and mutators + +extension ChytridiaceaeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data) + self.init(batidaceae: me.batidaceae, brechites: me.brechites, codespairer: me.codespairer, emery: me.emery, enervative: me.enervative, excriminate: me.excriminate, goshenite: me.goshenite, grime: me.grime, gritten: me.gritten, hectorly: me.hectorly, intermediation: me.intermediation, meeterly: me.meeterly, narraganset: me.narraganset, onymatic: me.onymatic, paddlecock: me.paddlecock, thana: me.thana, thornily: me.thornily, uckia: me.uckia, unmettle: me.unmettle, vorticellid: me.vorticellid) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + batidaceae: JSONNull?? = nil, + brechites: JSONNull?? = nil, + codespairer: JSONNull?? = nil, + emery: JSONNull?? = nil, + enervative: JSONNull?? = nil, + excriminate: JSONNull?? = nil, + goshenite: JSONNull?? = nil, + grime: JSONNull?? = nil, + gritten: JSONNull?? = nil, + hectorly: JSONNull?? = nil, + intermediation: JSONNull?? = nil, + meeterly: JSONNull?? = nil, + narraganset: JSONNull?? = nil, + onymatic: JSONNull?? = nil, + paddlecock: JSONNull?? = nil, + thana: JSONNull?? = nil, + thornily: JSONNull?? = nil, + uckia: JSONNull?? = nil, + unmettle: JSONNull?? = nil, + vorticellid: JSONNull?? = nil + ) -> ChytridiaceaeClass { + return ChytridiaceaeClass( + batidaceae: batidaceae ?? self.batidaceae, + brechites: brechites ?? self.brechites, + codespairer: codespairer ?? self.codespairer, + emery: emery ?? self.emery, + enervative: enervative ?? self.enervative, + excriminate: excriminate ?? self.excriminate, + goshenite: goshenite ?? self.goshenite, + grime: grime ?? self.grime, + gritten: gritten ?? self.gritten, + hectorly: hectorly ?? self.hectorly, + intermediation: intermediation ?? self.intermediation, + meeterly: meeterly ?? self.meeterly, + narraganset: narraganset ?? self.narraganset, + onymatic: onymatic ?? self.onymatic, + paddlecock: paddlecock ?? self.paddlecock, + thana: thana ?? self.thana, + thornily: thornily ?? self.thornily, + uckia: uckia ?? self.uckia, + unmettle: unmettle ?? self.unmettle, + vorticellid: vorticellid ?? self.vorticellid + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiscordiaElement: Codable, Sendable { + case discordiaClass(DiscordiaClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiscordiaClass.self) { + self = .discordiaClass(x) + return + } + throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .discordiaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiscordiaClass +final class DiscordiaClass: Codable, Sendable { + let altaic: Int? + let amoristic: Int? + let blennophthalmia: Int? + let catharticalness: Double? + let chirotherium: Int? + let disciplinability: Int? + let disdiapason: String? + let goofer: Int? + let homocerc: Bool? + let laryngograph: Int? + let leucitis: Int? + let lymphocyst: Int? + let microcosmology: Int? + let nauseation: Int? + let nonbookish: JSONNull? + let patarin: Int? + let preliberal: Int? + let prettifier: Int? + let rangework: Int? + let redient: Int? + let subfusiform: Int? + let suicidical: Int? + let swow: Int? + let wastrel: Int? + let wingle: Int? + + enum CodingKeys: String, CodingKey { + case altaic = "Altaic" + case amoristic = "amoristic" + case blennophthalmia = "blennophthalmia" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disciplinability = "disciplinability" + case disdiapason = "disdiapason" + case goofer = "goofer" + case homocerc = "homocerc" + case laryngograph = "laryngograph" + case leucitis = "leucitis" + case lymphocyst = "lymphocyst" + case microcosmology = "microcosmology" + case nauseation = "nauseation" + case nonbookish = "nonbookish" + case patarin = "Patarin" + case preliberal = "preliberal" + case prettifier = "prettifier" + case rangework = "rangework" + case redient = "redient" + case subfusiform = "subfusiform" + case suicidical = "suicidical" + case swow = "swow" + case wastrel = "wastrel" + case wingle = "wingle" + } + + init(altaic: Int?, amoristic: Int?, blennophthalmia: Int?, catharticalness: Double?, chirotherium: Int?, disciplinability: Int?, disdiapason: String?, goofer: Int?, homocerc: Bool?, laryngograph: Int?, leucitis: Int?, lymphocyst: Int?, microcosmology: Int?, nauseation: Int?, nonbookish: JSONNull?, patarin: Int?, preliberal: Int?, prettifier: Int?, rangework: Int?, redient: Int?, subfusiform: Int?, suicidical: Int?, swow: Int?, wastrel: Int?, wingle: Int?) { + self.altaic = altaic + self.amoristic = amoristic + self.blennophthalmia = blennophthalmia + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disciplinability = disciplinability + self.disdiapason = disdiapason + self.goofer = goofer + self.homocerc = homocerc + self.laryngograph = laryngograph + self.leucitis = leucitis + self.lymphocyst = lymphocyst + self.microcosmology = microcosmology + self.nauseation = nauseation + self.nonbookish = nonbookish + self.patarin = patarin + self.preliberal = preliberal + self.prettifier = prettifier + self.rangework = rangework + self.redient = redient + self.subfusiform = subfusiform + self.suicidical = suicidical + self.swow = swow + self.wastrel = wastrel + self.wingle = wingle + } +} + +// MARK: DiscordiaClass convenience initializers and mutators + +extension DiscordiaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiscordiaClass.self, from: data) + self.init(altaic: me.altaic, amoristic: me.amoristic, blennophthalmia: me.blennophthalmia, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disciplinability: me.disciplinability, disdiapason: me.disdiapason, goofer: me.goofer, homocerc: me.homocerc, laryngograph: me.laryngograph, leucitis: me.leucitis, lymphocyst: me.lymphocyst, microcosmology: me.microcosmology, nauseation: me.nauseation, nonbookish: me.nonbookish, patarin: me.patarin, preliberal: me.preliberal, prettifier: me.prettifier, rangework: me.rangework, redient: me.redient, subfusiform: me.subfusiform, suicidical: me.suicidical, swow: me.swow, wastrel: me.wastrel, wingle: me.wingle) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + altaic: Int?? = nil, + amoristic: Int?? = nil, + blennophthalmia: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disciplinability: Int?? = nil, + disdiapason: String?? = nil, + goofer: Int?? = nil, + homocerc: Bool?? = nil, + laryngograph: Int?? = nil, + leucitis: Int?? = nil, + lymphocyst: Int?? = nil, + microcosmology: Int?? = nil, + nauseation: Int?? = nil, + nonbookish: JSONNull?? = nil, + patarin: Int?? = nil, + preliberal: Int?? = nil, + prettifier: Int?? = nil, + rangework: Int?? = nil, + redient: Int?? = nil, + subfusiform: Int?? = nil, + suicidical: Int?? = nil, + swow: Int?? = nil, + wastrel: Int?? = nil, + wingle: Int?? = nil + ) -> DiscordiaClass { + return DiscordiaClass( + altaic: altaic ?? self.altaic, + amoristic: amoristic ?? self.amoristic, + blennophthalmia: blennophthalmia ?? self.blennophthalmia, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disciplinability: disciplinability ?? self.disciplinability, + disdiapason: disdiapason ?? self.disdiapason, + goofer: goofer ?? self.goofer, + homocerc: homocerc ?? self.homocerc, + laryngograph: laryngograph ?? self.laryngograph, + leucitis: leucitis ?? self.leucitis, + lymphocyst: lymphocyst ?? self.lymphocyst, + microcosmology: microcosmology ?? self.microcosmology, + nauseation: nauseation ?? self.nauseation, + nonbookish: nonbookish ?? self.nonbookish, + patarin: patarin ?? self.patarin, + preliberal: preliberal ?? self.preliberal, + prettifier: prettifier ?? self.prettifier, + rangework: rangework ?? self.rangework, + redient: redient ?? self.redient, + subfusiform: subfusiform ?? self.subfusiform, + suicidical: suicidical ?? self.suicidical, + swow: swow ?? self.swow, + wastrel: wastrel ?? self.wastrel, + wingle: wingle ?? self.wingle + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Endomyce: Codable, Sendable { + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Epinephelidae: Codable, Sendable { + case bool(Bool) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eupatorium: Codable, Sendable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum GryphosaurusElement: Codable, Sendable { + case gryphosaurusClass(GryphosaurusClass) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(GryphosaurusClass.self) { + self = .gryphosaurusClass(x) + return + } + throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .gryphosaurusClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - GryphosaurusClass +final class GryphosaurusClass: Codable, Sendable { + let amissibility: JSONNull? + let burushaski: JSONNull? + let citronin: JSONNull? + let coplaintiff: JSONNull? + let disquisitionary: JSONNull? + let enoplan: JSONNull? + let faintness: JSONNull? + let hebetomy: JSONNull? + let islandry: JSONNull? + let lameduck: JSONNull? + let overbattle: JSONNull? + let overinterested: JSONNull? + let phrenologic: JSONNull? + let rainband: JSONNull? + let shiningly: JSONNull? + let stamineous: JSONNull? + let subscapularis: JSONNull? + let tahami: JSONNull? + let undaubed: JSONNull? + let underntime: JSONNull? + + enum CodingKeys: String, CodingKey { + case amissibility = "amissibility" + case burushaski = "Burushaski" + case citronin = "citronin" + case coplaintiff = "coplaintiff" + case disquisitionary = "disquisitionary" + case enoplan = "enoplan" + case faintness = "faintness" + case hebetomy = "hebetomy" + case islandry = "islandry" + case lameduck = "lameduck" + case overbattle = "overbattle" + case overinterested = "overinterested" + case phrenologic = "phrenologic" + case rainband = "rainband" + case shiningly = "shiningly" + case stamineous = "stamineous" + case subscapularis = "subscapularis" + case tahami = "Tahami" + case undaubed = "undaubed" + case underntime = "underntime" + } + + init(amissibility: JSONNull?, burushaski: JSONNull?, citronin: JSONNull?, coplaintiff: JSONNull?, disquisitionary: JSONNull?, enoplan: JSONNull?, faintness: JSONNull?, hebetomy: JSONNull?, islandry: JSONNull?, lameduck: JSONNull?, overbattle: JSONNull?, overinterested: JSONNull?, phrenologic: JSONNull?, rainband: JSONNull?, shiningly: JSONNull?, stamineous: JSONNull?, subscapularis: JSONNull?, tahami: JSONNull?, undaubed: JSONNull?, underntime: JSONNull?) { + self.amissibility = amissibility + self.burushaski = burushaski + self.citronin = citronin + self.coplaintiff = coplaintiff + self.disquisitionary = disquisitionary + self.enoplan = enoplan + self.faintness = faintness + self.hebetomy = hebetomy + self.islandry = islandry + self.lameduck = lameduck + self.overbattle = overbattle + self.overinterested = overinterested + self.phrenologic = phrenologic + self.rainband = rainband + self.shiningly = shiningly + self.stamineous = stamineous + self.subscapularis = subscapularis + self.tahami = tahami + self.undaubed = undaubed + self.underntime = underntime + } +} + +// MARK: GryphosaurusClass convenience initializers and mutators + +extension GryphosaurusClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(GryphosaurusClass.self, from: data) + self.init(amissibility: me.amissibility, burushaski: me.burushaski, citronin: me.citronin, coplaintiff: me.coplaintiff, disquisitionary: me.disquisitionary, enoplan: me.enoplan, faintness: me.faintness, hebetomy: me.hebetomy, islandry: me.islandry, lameduck: me.lameduck, overbattle: me.overbattle, overinterested: me.overinterested, phrenologic: me.phrenologic, rainband: me.rainband, shiningly: me.shiningly, stamineous: me.stamineous, subscapularis: me.subscapularis, tahami: me.tahami, undaubed: me.undaubed, underntime: me.underntime) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amissibility: JSONNull?? = nil, + burushaski: JSONNull?? = nil, + citronin: JSONNull?? = nil, + coplaintiff: JSONNull?? = nil, + disquisitionary: JSONNull?? = nil, + enoplan: JSONNull?? = nil, + faintness: JSONNull?? = nil, + hebetomy: JSONNull?? = nil, + islandry: JSONNull?? = nil, + lameduck: JSONNull?? = nil, + overbattle: JSONNull?? = nil, + overinterested: JSONNull?? = nil, + phrenologic: JSONNull?? = nil, + rainband: JSONNull?? = nil, + shiningly: JSONNull?? = nil, + stamineous: JSONNull?? = nil, + subscapularis: JSONNull?? = nil, + tahami: JSONNull?? = nil, + undaubed: JSONNull?? = nil, + underntime: JSONNull?? = nil + ) -> GryphosaurusClass { + return GryphosaurusClass( + amissibility: amissibility ?? self.amissibility, + burushaski: burushaski ?? self.burushaski, + citronin: citronin ?? self.citronin, + coplaintiff: coplaintiff ?? self.coplaintiff, + disquisitionary: disquisitionary ?? self.disquisitionary, + enoplan: enoplan ?? self.enoplan, + faintness: faintness ?? self.faintness, + hebetomy: hebetomy ?? self.hebetomy, + islandry: islandry ?? self.islandry, + lameduck: lameduck ?? self.lameduck, + overbattle: overbattle ?? self.overbattle, + overinterested: overinterested ?? self.overinterested, + phrenologic: phrenologic ?? self.phrenologic, + rainband: rainband ?? self.rainband, + shiningly: shiningly ?? self.shiningly, + stamineous: stamineous ?? self.stamineous, + subscapularis: subscapularis ?? self.subscapularis, + tahami: tahami ?? self.tahami, + undaubed: undaubed ?? self.undaubed, + underntime: underntime ?? self.underntime + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Koryak: Codable, Sendable { + case string(String) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum LaviniaElement: Codable, Sendable { + case laviniaClass(LaviniaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LaviniaClass.self) { + self = .laviniaClass(x) + return + } + throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .laviniaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - LaviniaClass +final class LaviniaClass: Codable, Sendable { + let agitable: Int? + let asininity: Int? + let benefiter: Int? + let bronzelike: Int? + let catharticalness: Double? + let chirotherium: Int? + let cholesteatomatous: Int? + let deprivement: Int? + let disdiapason: String? + let flippantness: Int? + let fogproof: Int? + let homocerc: Bool? + let merrymeeting: Int? + let nonbookish: JSONNull? + let overcareful: Int? + let panaris: Int? + let preacceptance: Int? + let quinoxaline: Int? + let sig: Int? + let superconfusion: Int? + let tacana: Int? + let tillotter: Int? + let tranquillize: Int? + let unquestionable: Int? + let uproute: Int? + + enum CodingKeys: String, CodingKey { + case agitable = "agitable" + case asininity = "asininity" + case benefiter = "benefiter" + case bronzelike = "bronzelike" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cholesteatomatous = "cholesteatomatous" + case deprivement = "deprivement" + case disdiapason = "disdiapason" + case flippantness = "flippantness" + case fogproof = "fogproof" + case homocerc = "homocerc" + case merrymeeting = "merrymeeting" + case nonbookish = "nonbookish" + case overcareful = "overcareful" + case panaris = "panaris" + case preacceptance = "preacceptance" + case quinoxaline = "quinoxaline" + case sig = "sig" + case superconfusion = "superconfusion" + case tacana = "Tacana" + case tillotter = "tillotter" + case tranquillize = "tranquillize" + case unquestionable = "unquestionable" + case uproute = "uproute" + } + + init(agitable: Int?, asininity: Int?, benefiter: Int?, bronzelike: Int?, catharticalness: Double?, chirotherium: Int?, cholesteatomatous: Int?, deprivement: Int?, disdiapason: String?, flippantness: Int?, fogproof: Int?, homocerc: Bool?, merrymeeting: Int?, nonbookish: JSONNull?, overcareful: Int?, panaris: Int?, preacceptance: Int?, quinoxaline: Int?, sig: Int?, superconfusion: Int?, tacana: Int?, tillotter: Int?, tranquillize: Int?, unquestionable: Int?, uproute: Int?) { + self.agitable = agitable + self.asininity = asininity + self.benefiter = benefiter + self.bronzelike = bronzelike + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.cholesteatomatous = cholesteatomatous + self.deprivement = deprivement + self.disdiapason = disdiapason + self.flippantness = flippantness + self.fogproof = fogproof + self.homocerc = homocerc + self.merrymeeting = merrymeeting + self.nonbookish = nonbookish + self.overcareful = overcareful + self.panaris = panaris + self.preacceptance = preacceptance + self.quinoxaline = quinoxaline + self.sig = sig + self.superconfusion = superconfusion + self.tacana = tacana + self.tillotter = tillotter + self.tranquillize = tranquillize + self.unquestionable = unquestionable + self.uproute = uproute + } +} + +// MARK: LaviniaClass convenience initializers and mutators + +extension LaviniaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LaviniaClass.self, from: data) + self.init(agitable: me.agitable, asininity: me.asininity, benefiter: me.benefiter, bronzelike: me.bronzelike, catharticalness: me.catharticalness, chirotherium: me.chirotherium, cholesteatomatous: me.cholesteatomatous, deprivement: me.deprivement, disdiapason: me.disdiapason, flippantness: me.flippantness, fogproof: me.fogproof, homocerc: me.homocerc, merrymeeting: me.merrymeeting, nonbookish: me.nonbookish, overcareful: me.overcareful, panaris: me.panaris, preacceptance: me.preacceptance, quinoxaline: me.quinoxaline, sig: me.sig, superconfusion: me.superconfusion, tacana: me.tacana, tillotter: me.tillotter, tranquillize: me.tranquillize, unquestionable: me.unquestionable, uproute: me.uproute) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + agitable: Int?? = nil, + asininity: Int?? = nil, + benefiter: Int?? = nil, + bronzelike: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cholesteatomatous: Int?? = nil, + deprivement: Int?? = nil, + disdiapason: String?? = nil, + flippantness: Int?? = nil, + fogproof: Int?? = nil, + homocerc: Bool?? = nil, + merrymeeting: Int?? = nil, + nonbookish: JSONNull?? = nil, + overcareful: Int?? = nil, + panaris: Int?? = nil, + preacceptance: Int?? = nil, + quinoxaline: Int?? = nil, + sig: Int?? = nil, + superconfusion: Int?? = nil, + tacana: Int?? = nil, + tillotter: Int?? = nil, + tranquillize: Int?? = nil, + unquestionable: Int?? = nil, + uproute: Int?? = nil + ) -> LaviniaClass { + return LaviniaClass( + agitable: agitable ?? self.agitable, + asininity: asininity ?? self.asininity, + benefiter: benefiter ?? self.benefiter, + bronzelike: bronzelike ?? self.bronzelike, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous, + deprivement: deprivement ?? self.deprivement, + disdiapason: disdiapason ?? self.disdiapason, + flippantness: flippantness ?? self.flippantness, + fogproof: fogproof ?? self.fogproof, + homocerc: homocerc ?? self.homocerc, + merrymeeting: merrymeeting ?? self.merrymeeting, + nonbookish: nonbookish ?? self.nonbookish, + overcareful: overcareful ?? self.overcareful, + panaris: panaris ?? self.panaris, + preacceptance: preacceptance ?? self.preacceptance, + quinoxaline: quinoxaline ?? self.quinoxaline, + sig: sig ?? self.sig, + superconfusion: superconfusion ?? self.superconfusion, + tacana: tacana ?? self.tacana, + tillotter: tillotter ?? self.tillotter, + tranquillize: tranquillize ?? self.tranquillize, + unquestionable: unquestionable ?? self.unquestionable, + uproute: uproute ?? self.uproute + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OskarElement: Codable, Sendable { + case integerArray([Int]) + case oskarClass(OskarClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(OskarClass.self) { + self = .oskarClass(x) + return + } + throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .oskarClass(let x): + try container.encode(x) + } + } +} + +// MARK: - OskarClass +final class OskarClass: Codable, Sendable { + let acrobates: JSONNull? + let beanshooter: JSONNull? + let bearhound: JSONNull? + let cayuga: JSONNull? + let guarneri: JSONNull? + let hypochondriacism: JSONNull? + let indication: JSONNull? + let jaculative: JSONNull? + let nagana: JSONNull? + let netherlandish: JSONNull? + let noctivagous: JSONNull? + let nonphysiological: JSONNull? + let praxis: JSONNull? + let provision: JSONNull? + let subterhuman: JSONNull? + let sunlit: JSONNull? + let syncraniate: JSONNull? + let teachment: JSONNull? + let unmutinous: JSONNull? + let unstoppable: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrobates = "Acrobates" + case beanshooter = "beanshooter" + case bearhound = "bearhound" + case cayuga = "Cayuga" + case guarneri = "guarneri" + case hypochondriacism = "hypochondriacism" + case indication = "indication" + case jaculative = "jaculative" + case nagana = "nagana" + case netherlandish = "Netherlandish" + case noctivagous = "noctivagous" + case nonphysiological = "nonphysiological" + case praxis = "praxis" + case provision = "provision" + case subterhuman = "subterhuman" + case sunlit = "sunlit" + case syncraniate = "syncraniate" + case teachment = "teachment" + case unmutinous = "unmutinous" + case unstoppable = "unstoppable" + } + + init(acrobates: JSONNull?, beanshooter: JSONNull?, bearhound: JSONNull?, cayuga: JSONNull?, guarneri: JSONNull?, hypochondriacism: JSONNull?, indication: JSONNull?, jaculative: JSONNull?, nagana: JSONNull?, netherlandish: JSONNull?, noctivagous: JSONNull?, nonphysiological: JSONNull?, praxis: JSONNull?, provision: JSONNull?, subterhuman: JSONNull?, sunlit: JSONNull?, syncraniate: JSONNull?, teachment: JSONNull?, unmutinous: JSONNull?, unstoppable: JSONNull?) { + self.acrobates = acrobates + self.beanshooter = beanshooter + self.bearhound = bearhound + self.cayuga = cayuga + self.guarneri = guarneri + self.hypochondriacism = hypochondriacism + self.indication = indication + self.jaculative = jaculative + self.nagana = nagana + self.netherlandish = netherlandish + self.noctivagous = noctivagous + self.nonphysiological = nonphysiological + self.praxis = praxis + self.provision = provision + self.subterhuman = subterhuman + self.sunlit = sunlit + self.syncraniate = syncraniate + self.teachment = teachment + self.unmutinous = unmutinous + self.unstoppable = unstoppable + } +} + +// MARK: OskarClass convenience initializers and mutators + +extension OskarClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OskarClass.self, from: data) + self.init(acrobates: me.acrobates, beanshooter: me.beanshooter, bearhound: me.bearhound, cayuga: me.cayuga, guarneri: me.guarneri, hypochondriacism: me.hypochondriacism, indication: me.indication, jaculative: me.jaculative, nagana: me.nagana, netherlandish: me.netherlandish, noctivagous: me.noctivagous, nonphysiological: me.nonphysiological, praxis: me.praxis, provision: me.provision, subterhuman: me.subterhuman, sunlit: me.sunlit, syncraniate: me.syncraniate, teachment: me.teachment, unmutinous: me.unmutinous, unstoppable: me.unstoppable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrobates: JSONNull?? = nil, + beanshooter: JSONNull?? = nil, + bearhound: JSONNull?? = nil, + cayuga: JSONNull?? = nil, + guarneri: JSONNull?? = nil, + hypochondriacism: JSONNull?? = nil, + indication: JSONNull?? = nil, + jaculative: JSONNull?? = nil, + nagana: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + noctivagous: JSONNull?? = nil, + nonphysiological: JSONNull?? = nil, + praxis: JSONNull?? = nil, + provision: JSONNull?? = nil, + subterhuman: JSONNull?? = nil, + sunlit: JSONNull?? = nil, + syncraniate: JSONNull?? = nil, + teachment: JSONNull?? = nil, + unmutinous: JSONNull?? = nil, + unstoppable: JSONNull?? = nil + ) -> OskarClass { + return OskarClass( + acrobates: acrobates ?? self.acrobates, + beanshooter: beanshooter ?? self.beanshooter, + bearhound: bearhound ?? self.bearhound, + cayuga: cayuga ?? self.cayuga, + guarneri: guarneri ?? self.guarneri, + hypochondriacism: hypochondriacism ?? self.hypochondriacism, + indication: indication ?? self.indication, + jaculative: jaculative ?? self.jaculative, + nagana: nagana ?? self.nagana, + netherlandish: netherlandish ?? self.netherlandish, + noctivagous: noctivagous ?? self.noctivagous, + nonphysiological: nonphysiological ?? self.nonphysiological, + praxis: praxis ?? self.praxis, + provision: provision ?? self.provision, + subterhuman: subterhuman ?? self.subterhuman, + sunlit: sunlit ?? self.sunlit, + syncraniate: syncraniate ?? self.syncraniate, + teachment: teachment ?? self.teachment, + unmutinous: unmutinous ?? self.unmutinous, + unstoppable: unstoppable ?? self.unstoppable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum RebeccaElement: Codable, Sendable { + case integer(Int) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Rhomboganoidei: Codable, Sendable { + case integerArray([Int]) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Ruellia: Codable, Sendable { + case bool(Bool) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum School: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Shakespearolater: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations3.json/default/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations3.json/default/quicktype.swift new file mode 100644 index 0000000..46f0024 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations3.json/default/quicktype.swift @@ -0,0 +1,3137 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Sendable { + let juror: [JurorElement] + let kongoni: [Kongoni] + let ladronism: [LadronismElement] + let landlubberly: [LandlubberlyElement] + let listener: [Listener] + let lupus: [LupusElement] + let maslin: [Maslin] + let monazite: [MonaziteElement] + let monoliteral: [Monoliteral] + let monotheistically: [MonotheisticallyElement] + let montage: [Montage] + let moralness: [Moralness] + let mowra: [MonaziteClass?] + let mulishly: [Mulishly] + let myoscope: [Myoscope] + let nach: [[Int?]?] + let neuromastic: [Neuromastic] + let noncontributing: [Noncontributing] + let nonnervous: [Nonnervous] + let nonvaluation: [Nonvaluation] + let occupationalist: [OccupationalistElement] + let outrival: [OutrivalElement] + let paleographically: [Paleographically] + let pamphletwise: [Pamphletwise] + let pediatrics: [Pediatric] + let perceptive: [Bool] + let piaculum: [PiaculumElement] + let piccadilly: [Piccadilly] + let piffler: [Piffler] + let pithful: [Pithful] + let placuntitis: [Placuntiti] + let plectopterous: [Plectopterous] + let pneumocele: [Pneumocele?] + let poliorcetic: [Poliorcetic] + let poormaster: [Poormaster] + let potwhisky: [PotwhiskyElement] + let practicalizer: [Practicalizer] + let prefreshman: [PrefreshmanElement] + let prehensility: [Prehensility] + let prevoidance: [Prevoidance] + let probant: [[String: Int?]] + let protext: [Protext] + + enum CodingKeys: String, CodingKey { + case juror = "juror" + case kongoni = "kongoni" + case ladronism = "ladronism" + case landlubberly = "landlubberly" + case listener = "listener" + case lupus = "lupus" + case maslin = "maslin" + case monazite = "monazite" + case monoliteral = "monoliteral" + case monotheistically = "monotheistically" + case montage = "montage" + case moralness = "moralness" + case mowra = "mowra" + case mulishly = "mulishly" + case myoscope = "myoscope" + case nach = "nach" + case neuromastic = "neuromastic" + case noncontributing = "noncontributing" + case nonnervous = "nonnervous" + case nonvaluation = "nonvaluation" + case occupationalist = "occupationalist" + case outrival = "outrival" + case paleographically = "paleographically" + case pamphletwise = "pamphletwise" + case pediatrics = "pediatrics" + case perceptive = "perceptive" + case piaculum = "piaculum" + case piccadilly = "piccadilly" + case piffler = "piffler" + case pithful = "pithful" + case placuntitis = "placuntitis" + case plectopterous = "plectopterous" + case pneumocele = "pneumocele" + case poliorcetic = "poliorcetic" + case poormaster = "poormaster" + case potwhisky = "potwhisky" + case practicalizer = "practicalizer" + case prefreshman = "prefreshman" + case prehensility = "prehensility" + case prevoidance = "prevoidance" + case probant = "probant" + case protext = "protext" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + juror: [JurorElement]? = nil, + kongoni: [Kongoni]? = nil, + ladronism: [LadronismElement]? = nil, + landlubberly: [LandlubberlyElement]? = nil, + listener: [Listener]? = nil, + lupus: [LupusElement]? = nil, + maslin: [Maslin]? = nil, + monazite: [MonaziteElement]? = nil, + monoliteral: [Monoliteral]? = nil, + monotheistically: [MonotheisticallyElement]? = nil, + montage: [Montage]? = nil, + moralness: [Moralness]? = nil, + mowra: [MonaziteClass?]? = nil, + mulishly: [Mulishly]? = nil, + myoscope: [Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [Neuromastic]? = nil, + noncontributing: [Noncontributing]? = nil, + nonnervous: [Nonnervous]? = nil, + nonvaluation: [Nonvaluation]? = nil, + occupationalist: [OccupationalistElement]? = nil, + outrival: [OutrivalElement]? = nil, + paleographically: [Paleographically]? = nil, + pamphletwise: [Pamphletwise]? = nil, + pediatrics: [Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [PiaculumElement]? = nil, + piccadilly: [Piccadilly]? = nil, + piffler: [Piffler]? = nil, + pithful: [Pithful]? = nil, + placuntitis: [Placuntiti]? = nil, + plectopterous: [Plectopterous]? = nil, + pneumocele: [Pneumocele?]? = nil, + poliorcetic: [Poliorcetic]? = nil, + poormaster: [Poormaster]? = nil, + potwhisky: [PotwhiskyElement]? = nil, + practicalizer: [Practicalizer]? = nil, + prefreshman: [PrefreshmanElement]? = nil, + prehensility: [Prehensility]? = nil, + prevoidance: [Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [Protext]? = nil + ) -> TopLevel { + return TopLevel( + juror: juror ?? self.juror, + kongoni: kongoni ?? self.kongoni, + ladronism: ladronism ?? self.ladronism, + landlubberly: landlubberly ?? self.landlubberly, + listener: listener ?? self.listener, + lupus: lupus ?? self.lupus, + maslin: maslin ?? self.maslin, + monazite: monazite ?? self.monazite, + monoliteral: monoliteral ?? self.monoliteral, + monotheistically: monotheistically ?? self.monotheistically, + montage: montage ?? self.montage, + moralness: moralness ?? self.moralness, + mowra: mowra ?? self.mowra, + mulishly: mulishly ?? self.mulishly, + myoscope: myoscope ?? self.myoscope, + nach: nach ?? self.nach, + neuromastic: neuromastic ?? self.neuromastic, + noncontributing: noncontributing ?? self.noncontributing, + nonnervous: nonnervous ?? self.nonnervous, + nonvaluation: nonvaluation ?? self.nonvaluation, + occupationalist: occupationalist ?? self.occupationalist, + outrival: outrival ?? self.outrival, + paleographically: paleographically ?? self.paleographically, + pamphletwise: pamphletwise ?? self.pamphletwise, + pediatrics: pediatrics ?? self.pediatrics, + perceptive: perceptive ?? self.perceptive, + piaculum: piaculum ?? self.piaculum, + piccadilly: piccadilly ?? self.piccadilly, + piffler: piffler ?? self.piffler, + pithful: pithful ?? self.pithful, + placuntitis: placuntitis ?? self.placuntitis, + plectopterous: plectopterous ?? self.plectopterous, + pneumocele: pneumocele ?? self.pneumocele, + poliorcetic: poliorcetic ?? self.poliorcetic, + poormaster: poormaster ?? self.poormaster, + potwhisky: potwhisky ?? self.potwhisky, + practicalizer: practicalizer ?? self.practicalizer, + prefreshman: prefreshman ?? self.prefreshman, + prehensility: prehensility ?? self.prehensility, + prevoidance: prevoidance ?? self.prevoidance, + probant: probant ?? self.probant, + protext: protext ?? self.protext + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum JurorElement: Codable, Sendable { + case bool(Bool) + case jurorClass(JurorClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(JurorClass.self) { + self = .jurorClass(x) + return + } + throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .jurorClass(let x): + try container.encode(x) + } + } +} + +// MARK: - JurorClass +struct JurorClass: Codable, Sendable { + let adipsy: JSONNull? + let auxiliator: JSONNull? + let benda: JSONNull? + let benjamin: JSONNull? + let brandling: JSONNull? + let epicurishly: JSONNull? + let eremochaetous: JSONNull? + let marten: JSONNull? + let monocline: JSONNull? + let olea: JSONNull? + let palgat: JSONNull? + let pennyworth: JSONNull? + let pioury: JSONNull? + let pragmatistic: JSONNull? + let stylelessness: JSONNull? + let systematical: JSONNull? + let thready: JSONNull? + let uncontemporary: JSONNull? + let uncouched: JSONNull? + let uninhabitedness: JSONNull? + + enum CodingKeys: String, CodingKey { + case adipsy = "adipsy" + case auxiliator = "auxiliator" + case benda = "benda" + case benjamin = "benjamin" + case brandling = "brandling" + case epicurishly = "epicurishly" + case eremochaetous = "eremochaetous" + case marten = "marten" + case monocline = "monocline" + case olea = "Olea" + case palgat = "palgat" + case pennyworth = "pennyworth" + case pioury = "pioury" + case pragmatistic = "pragmatistic" + case stylelessness = "stylelessness" + case systematical = "systematical" + case thready = "thready" + case uncontemporary = "uncontemporary" + case uncouched = "uncouched" + case uninhabitedness = "uninhabitedness" + } +} + +// MARK: JurorClass convenience initializers and mutators + +extension JurorClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(JurorClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adipsy: JSONNull?? = nil, + auxiliator: JSONNull?? = nil, + benda: JSONNull?? = nil, + benjamin: JSONNull?? = nil, + brandling: JSONNull?? = nil, + epicurishly: JSONNull?? = nil, + eremochaetous: JSONNull?? = nil, + marten: JSONNull?? = nil, + monocline: JSONNull?? = nil, + olea: JSONNull?? = nil, + palgat: JSONNull?? = nil, + pennyworth: JSONNull?? = nil, + pioury: JSONNull?? = nil, + pragmatistic: JSONNull?? = nil, + stylelessness: JSONNull?? = nil, + systematical: JSONNull?? = nil, + thready: JSONNull?? = nil, + uncontemporary: JSONNull?? = nil, + uncouched: JSONNull?? = nil, + uninhabitedness: JSONNull?? = nil + ) -> JurorClass { + return JurorClass( + adipsy: adipsy ?? self.adipsy, + auxiliator: auxiliator ?? self.auxiliator, + benda: benda ?? self.benda, + benjamin: benjamin ?? self.benjamin, + brandling: brandling ?? self.brandling, + epicurishly: epicurishly ?? self.epicurishly, + eremochaetous: eremochaetous ?? self.eremochaetous, + marten: marten ?? self.marten, + monocline: monocline ?? self.monocline, + olea: olea ?? self.olea, + palgat: palgat ?? self.palgat, + pennyworth: pennyworth ?? self.pennyworth, + pioury: pioury ?? self.pioury, + pragmatistic: pragmatistic ?? self.pragmatistic, + stylelessness: stylelessness ?? self.stylelessness, + systematical: systematical ?? self.systematical, + thready: thready ?? self.thready, + uncontemporary: uncontemporary ?? self.uncontemporary, + uncouched: uncouched ?? self.uncouched, + uninhabitedness: uninhabitedness ?? self.uninhabitedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Kongoni: Codable, Sendable { + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum LadronismElement: Codable, Sendable { + case double(Double) + case ladronismClass(LadronismClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LadronismClass.self) { + self = .ladronismClass(x) + return + } + throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .ladronismClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - LadronismClass +struct LadronismClass: Codable, Sendable { + let acclaimer: JSONNull? + let achree: JSONNull? + let base: JSONNull? + let conundrumize: JSONNull? + let degerminator: JSONNull? + let describable: JSONNull? + let exasperatedly: JSONNull? + let heroine: JSONNull? + let indazin: JSONNull? + let luteous: JSONNull? + let papular: JSONNull? + let pritch: JSONNull? + let prodenia: JSONNull? + let seege: JSONNull? + let shopgirl: JSONNull? + let tragedietta: JSONNull? + let unsparse: JSONNull? + let uplook: JSONNull? + let vermiformis: JSONNull? + let whafabout: JSONNull? + + enum CodingKeys: String, CodingKey { + case acclaimer = "acclaimer" + case achree = "achree" + case base = "base" + case conundrumize = "conundrumize" + case degerminator = "degerminator" + case describable = "describable" + case exasperatedly = "exasperatedly" + case heroine = "heroine" + case indazin = "indazin" + case luteous = "luteous" + case papular = "papular" + case pritch = "pritch" + case prodenia = "Prodenia" + case seege = "seege" + case shopgirl = "shopgirl" + case tragedietta = "tragedietta" + case unsparse = "unsparse" + case uplook = "uplook" + case vermiformis = "vermiformis" + case whafabout = "whafabout" + } +} + +// MARK: LadronismClass convenience initializers and mutators + +extension LadronismClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LadronismClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acclaimer: JSONNull?? = nil, + achree: JSONNull?? = nil, + base: JSONNull?? = nil, + conundrumize: JSONNull?? = nil, + degerminator: JSONNull?? = nil, + describable: JSONNull?? = nil, + exasperatedly: JSONNull?? = nil, + heroine: JSONNull?? = nil, + indazin: JSONNull?? = nil, + luteous: JSONNull?? = nil, + papular: JSONNull?? = nil, + pritch: JSONNull?? = nil, + prodenia: JSONNull?? = nil, + seege: JSONNull?? = nil, + shopgirl: JSONNull?? = nil, + tragedietta: JSONNull?? = nil, + unsparse: JSONNull?? = nil, + uplook: JSONNull?? = nil, + vermiformis: JSONNull?? = nil, + whafabout: JSONNull?? = nil + ) -> LadronismClass { + return LadronismClass( + acclaimer: acclaimer ?? self.acclaimer, + achree: achree ?? self.achree, + base: base ?? self.base, + conundrumize: conundrumize ?? self.conundrumize, + degerminator: degerminator ?? self.degerminator, + describable: describable ?? self.describable, + exasperatedly: exasperatedly ?? self.exasperatedly, + heroine: heroine ?? self.heroine, + indazin: indazin ?? self.indazin, + luteous: luteous ?? self.luteous, + papular: papular ?? self.papular, + pritch: pritch ?? self.pritch, + prodenia: prodenia ?? self.prodenia, + seege: seege ?? self.seege, + shopgirl: shopgirl ?? self.shopgirl, + tragedietta: tragedietta ?? self.tragedietta, + unsparse: unsparse ?? self.unsparse, + uplook: uplook ?? self.uplook, + vermiformis: vermiformis ?? self.vermiformis, + whafabout: whafabout ?? self.whafabout + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum LandlubberlyElement: Codable, Sendable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(LandlubberlyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LandlubberlyClass.self) { + self = .landlubberlyClass(x) + return + } + throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .landlubberlyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - LandlubberlyClass +struct LandlubberlyClass: Codable, Sendable { + let acropoleis: JSONNull? + let aminate: JSONNull? + let amyraldism: JSONNull? + let bipenniform: JSONNull? + let bugre: JSONNull? + let calycule: JSONNull? + let caoutchouc: JSONNull? + let disprover: JSONNull? + let fitroot: JSONNull? + let fulgently: JSONNull? + let kickup: JSONNull? + let laevoversion: JSONNull? + let moter: JSONNull? + let objectivity: JSONNull? + let posterity: JSONNull? + let postnuptial: JSONNull? + let precedentary: JSONNull? + let saddling: JSONNull? + let subcurrent: JSONNull? + let unrecriminative: JSONNull? + + enum CodingKeys: String, CodingKey { + case acropoleis = "acropoleis" + case aminate = "aminate" + case amyraldism = "Amyraldism" + case bipenniform = "bipenniform" + case bugre = "bugre" + case calycule = "calycule" + case caoutchouc = "caoutchouc" + case disprover = "disprover" + case fitroot = "fitroot" + case fulgently = "fulgently" + case kickup = "kickup" + case laevoversion = "laevoversion" + case moter = "moter" + case objectivity = "objectivity" + case posterity = "posterity" + case postnuptial = "postnuptial" + case precedentary = "precedentary" + case saddling = "saddling" + case subcurrent = "subcurrent" + case unrecriminative = "unrecriminative" + } +} + +// MARK: LandlubberlyClass convenience initializers and mutators + +extension LandlubberlyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LandlubberlyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acropoleis: JSONNull?? = nil, + aminate: JSONNull?? = nil, + amyraldism: JSONNull?? = nil, + bipenniform: JSONNull?? = nil, + bugre: JSONNull?? = nil, + calycule: JSONNull?? = nil, + caoutchouc: JSONNull?? = nil, + disprover: JSONNull?? = nil, + fitroot: JSONNull?? = nil, + fulgently: JSONNull?? = nil, + kickup: JSONNull?? = nil, + laevoversion: JSONNull?? = nil, + moter: JSONNull?? = nil, + objectivity: JSONNull?? = nil, + posterity: JSONNull?? = nil, + postnuptial: JSONNull?? = nil, + precedentary: JSONNull?? = nil, + saddling: JSONNull?? = nil, + subcurrent: JSONNull?? = nil, + unrecriminative: JSONNull?? = nil + ) -> LandlubberlyClass { + return LandlubberlyClass( + acropoleis: acropoleis ?? self.acropoleis, + aminate: aminate ?? self.aminate, + amyraldism: amyraldism ?? self.amyraldism, + bipenniform: bipenniform ?? self.bipenniform, + bugre: bugre ?? self.bugre, + calycule: calycule ?? self.calycule, + caoutchouc: caoutchouc ?? self.caoutchouc, + disprover: disprover ?? self.disprover, + fitroot: fitroot ?? self.fitroot, + fulgently: fulgently ?? self.fulgently, + kickup: kickup ?? self.kickup, + laevoversion: laevoversion ?? self.laevoversion, + moter: moter ?? self.moter, + objectivity: objectivity ?? self.objectivity, + posterity: posterity ?? self.posterity, + postnuptial: postnuptial ?? self.postnuptial, + precedentary: precedentary ?? self.precedentary, + saddling: saddling ?? self.saddling, + subcurrent: subcurrent ?? self.subcurrent, + unrecriminative: unrecriminative ?? self.unrecriminative + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Listener: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum LupusElement: Codable, Sendable { + case integer(Int) + case lupusClass(LupusClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LupusClass.self) { + self = .lupusClass(x) + return + } + throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .lupusClass(let x): + try container.encode(x) + } + } +} + +// MARK: - LupusClass +struct LupusClass: Codable, Sendable { + let catharticalness: Double? + let chirotherium: Int? + let chlorioninae: Int? + let corvinae: Int? + let crassina: Int? + let disdiapason: String? + let exiguity: Int? + let farcist: Int? + let holographical: Int? + let homocerc: Bool? + let ichthyophagan: Int? + let implacable: Int? + let nonbookish: JSONNull? + let outshiner: Int? + let overweather: Int? + let protonegroid: Int? + let shallowish: Int? + let snoke: Int? + let snout: Int? + let surveillance: Int? + let threshingtime: Int? + let thysanocarpus: Int? + let unsignificantly: Int? + let unsnap: Int? + let vendible: Int? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorioninae = "Chlorioninae" + case corvinae = "Corvinae" + case crassina = "Crassina" + case disdiapason = "disdiapason" + case exiguity = "exiguity" + case farcist = "farcist" + case holographical = "holographical" + case homocerc = "homocerc" + case ichthyophagan = "ichthyophagan" + case implacable = "implacable" + case nonbookish = "nonbookish" + case outshiner = "outshiner" + case overweather = "overweather" + case protonegroid = "protonegroid" + case shallowish = "shallowish" + case snoke = "snoke" + case snout = "snout" + case surveillance = "surveillance" + case threshingtime = "threshingtime" + case thysanocarpus = "Thysanocarpus" + case unsignificantly = "unsignificantly" + case unsnap = "unsnap" + case vendible = "vendible" + } +} + +// MARK: LupusClass convenience initializers and mutators + +extension LupusClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LupusClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorioninae: Int?? = nil, + corvinae: Int?? = nil, + crassina: Int?? = nil, + disdiapason: String?? = nil, + exiguity: Int?? = nil, + farcist: Int?? = nil, + holographical: Int?? = nil, + homocerc: Bool?? = nil, + ichthyophagan: Int?? = nil, + implacable: Int?? = nil, + nonbookish: JSONNull?? = nil, + outshiner: Int?? = nil, + overweather: Int?? = nil, + protonegroid: Int?? = nil, + shallowish: Int?? = nil, + snoke: Int?? = nil, + snout: Int?? = nil, + surveillance: Int?? = nil, + threshingtime: Int?? = nil, + thysanocarpus: Int?? = nil, + unsignificantly: Int?? = nil, + unsnap: Int?? = nil, + vendible: Int?? = nil + ) -> LupusClass { + return LupusClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorioninae: chlorioninae ?? self.chlorioninae, + corvinae: corvinae ?? self.corvinae, + crassina: crassina ?? self.crassina, + disdiapason: disdiapason ?? self.disdiapason, + exiguity: exiguity ?? self.exiguity, + farcist: farcist ?? self.farcist, + holographical: holographical ?? self.holographical, + homocerc: homocerc ?? self.homocerc, + ichthyophagan: ichthyophagan ?? self.ichthyophagan, + implacable: implacable ?? self.implacable, + nonbookish: nonbookish ?? self.nonbookish, + outshiner: outshiner ?? self.outshiner, + overweather: overweather ?? self.overweather, + protonegroid: protonegroid ?? self.protonegroid, + shallowish: shallowish ?? self.shallowish, + snoke: snoke ?? self.snoke, + snout: snout ?? self.snout, + surveillance: surveillance ?? self.surveillance, + threshingtime: threshingtime ?? self.threshingtime, + thysanocarpus: thysanocarpus ?? self.thysanocarpus, + unsignificantly: unsignificantly ?? self.unsignificantly, + unsnap: unsnap ?? self.unsnap, + vendible: vendible ?? self.vendible + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Maslin +struct Maslin: Codable, Sendable { + let alicant: Int? + let antiatonement: JSONNull? + let anticorrosive: Int? + let aphidozer: JSONNull? + let bakuninist: JSONNull? + let be: Int? + let catharticalness: Double? + let chirotherium: Int? + let chub: Int? + let cuprosilicon: Int? + let curtailedly: Int? + let dellenite: Int? + let dimitry: Int? + let disdiapason: String? + let edifying: JSONNull? + let ethmoiditis: Int? + let gastralgy: JSONNull? + let goatherd: Int? + let hammerdress: Int? + let hangfire: JSONNull? + let homocerc: Bool? + let lacunosity: Int? + let longiloquence: JSONNull? + let mameliere: Int? + let motherless: JSONNull? + let nonbookish: JSONNull? + let noncorrodible: JSONNull? + let nonsensicality: JSONNull? + let oafishly: Int? + let pfund: JSONNull? + let preadvisory: JSONNull? + let retroflexed: JSONNull? + let saccharulmic: Int? + let scowlful: Int? + let secluded: JSONNull? + let slackage: JSONNull? + let sphaeridial: Int? + let spondulics: JSONNull? + let subsecive: Int? + let swellmobsman: JSONNull? + let trachyglossate: Int? + let trialogue: JSONNull? + let unassuaged: Int? + let ungross: JSONNull? + let unjudiciously: JSONNull? + + enum CodingKeys: String, CodingKey { + case alicant = "Alicant" + case antiatonement = "antiatonement" + case anticorrosive = "anticorrosive" + case aphidozer = "aphidozer" + case bakuninist = "Bakuninist" + case be = "be" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chub = "chub" + case cuprosilicon = "cuprosilicon" + case curtailedly = "curtailedly" + case dellenite = "dellenite" + case dimitry = "Dimitry" + case disdiapason = "disdiapason" + case edifying = "edifying" + case ethmoiditis = "ethmoiditis" + case gastralgy = "gastralgy" + case goatherd = "goatherd" + case hammerdress = "hammerdress" + case hangfire = "hangfire" + case homocerc = "homocerc" + case lacunosity = "lacunosity" + case longiloquence = "longiloquence" + case mameliere = "mameliere" + case motherless = "motherless" + case nonbookish = "nonbookish" + case noncorrodible = "noncorrodible" + case nonsensicality = "nonsensicality" + case oafishly = "oafishly" + case pfund = "pfund" + case preadvisory = "preadvisory" + case retroflexed = "retroflexed" + case saccharulmic = "saccharulmic" + case scowlful = "scowlful" + case secluded = "secluded" + case slackage = "slackage" + case sphaeridial = "sphaeridial" + case spondulics = "spondulics" + case subsecive = "subsecive" + case swellmobsman = "swellmobsman" + case trachyglossate = "trachyglossate" + case trialogue = "trialogue" + case unassuaged = "unassuaged" + case ungross = "ungross" + case unjudiciously = "unjudiciously" + } +} + +// MARK: Maslin convenience initializers and mutators + +extension Maslin { + init(data: Data) throws { + self = try newJSONDecoder().decode(Maslin.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alicant: Int?? = nil, + antiatonement: JSONNull?? = nil, + anticorrosive: Int?? = nil, + aphidozer: JSONNull?? = nil, + bakuninist: JSONNull?? = nil, + be: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chub: Int?? = nil, + cuprosilicon: Int?? = nil, + curtailedly: Int?? = nil, + dellenite: Int?? = nil, + dimitry: Int?? = nil, + disdiapason: String?? = nil, + edifying: JSONNull?? = nil, + ethmoiditis: Int?? = nil, + gastralgy: JSONNull?? = nil, + goatherd: Int?? = nil, + hammerdress: Int?? = nil, + hangfire: JSONNull?? = nil, + homocerc: Bool?? = nil, + lacunosity: Int?? = nil, + longiloquence: JSONNull?? = nil, + mameliere: Int?? = nil, + motherless: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + noncorrodible: JSONNull?? = nil, + nonsensicality: JSONNull?? = nil, + oafishly: Int?? = nil, + pfund: JSONNull?? = nil, + preadvisory: JSONNull?? = nil, + retroflexed: JSONNull?? = nil, + saccharulmic: Int?? = nil, + scowlful: Int?? = nil, + secluded: JSONNull?? = nil, + slackage: JSONNull?? = nil, + sphaeridial: Int?? = nil, + spondulics: JSONNull?? = nil, + subsecive: Int?? = nil, + swellmobsman: JSONNull?? = nil, + trachyglossate: Int?? = nil, + trialogue: JSONNull?? = nil, + unassuaged: Int?? = nil, + ungross: JSONNull?? = nil, + unjudiciously: JSONNull?? = nil + ) -> Maslin { + return Maslin( + alicant: alicant ?? self.alicant, + antiatonement: antiatonement ?? self.antiatonement, + anticorrosive: anticorrosive ?? self.anticorrosive, + aphidozer: aphidozer ?? self.aphidozer, + bakuninist: bakuninist ?? self.bakuninist, + be: be ?? self.be, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chub: chub ?? self.chub, + cuprosilicon: cuprosilicon ?? self.cuprosilicon, + curtailedly: curtailedly ?? self.curtailedly, + dellenite: dellenite ?? self.dellenite, + dimitry: dimitry ?? self.dimitry, + disdiapason: disdiapason ?? self.disdiapason, + edifying: edifying ?? self.edifying, + ethmoiditis: ethmoiditis ?? self.ethmoiditis, + gastralgy: gastralgy ?? self.gastralgy, + goatherd: goatherd ?? self.goatherd, + hammerdress: hammerdress ?? self.hammerdress, + hangfire: hangfire ?? self.hangfire, + homocerc: homocerc ?? self.homocerc, + lacunosity: lacunosity ?? self.lacunosity, + longiloquence: longiloquence ?? self.longiloquence, + mameliere: mameliere ?? self.mameliere, + motherless: motherless ?? self.motherless, + nonbookish: nonbookish ?? self.nonbookish, + noncorrodible: noncorrodible ?? self.noncorrodible, + nonsensicality: nonsensicality ?? self.nonsensicality, + oafishly: oafishly ?? self.oafishly, + pfund: pfund ?? self.pfund, + preadvisory: preadvisory ?? self.preadvisory, + retroflexed: retroflexed ?? self.retroflexed, + saccharulmic: saccharulmic ?? self.saccharulmic, + scowlful: scowlful ?? self.scowlful, + secluded: secluded ?? self.secluded, + slackage: slackage ?? self.slackage, + sphaeridial: sphaeridial ?? self.sphaeridial, + spondulics: spondulics ?? self.spondulics, + subsecive: subsecive ?? self.subsecive, + swellmobsman: swellmobsman ?? self.swellmobsman, + trachyglossate: trachyglossate ?? self.trachyglossate, + trialogue: trialogue ?? self.trialogue, + unassuaged: unassuaged ?? self.unassuaged, + ungross: ungross ?? self.ungross, + unjudiciously: unjudiciously ?? self.unjudiciously + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum MonaziteElement: Codable, Sendable { + case double(Double) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - MonaziteClass +struct MonaziteClass: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: MonaziteClass convenience initializers and mutators + +extension MonaziteClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(MonaziteClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> MonaziteClass { + return MonaziteClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Monoliteral: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum MonotheisticallyElement: Codable, Sendable { + case monotheisticallyClass(MonotheisticallyClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonotheisticallyClass.self) { + self = .monotheisticallyClass(x) + return + } + throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monotheisticallyClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - MonotheisticallyClass +struct MonotheisticallyClass: Codable, Sendable { + let blaspheme: JSONNull? + let catharticalness: Double? + let celiosalpingectomy: JSONNull? + let chirotherium: Int? + let consummativeness: JSONNull? + let disdiapason: String? + let egestive: JSONNull? + let enchylema: JSONNull? + let gasconade: JSONNull? + let holidayer: JSONNull? + let homocerc: Bool? + let intuitionalism: JSONNull? + let lophiostomate: JSONNull? + let nonbookish: JSONNull? + let nonvolition: JSONNull? + let palatableness: JSONNull? + let pimpery: JSONNull? + let previolation: JSONNull? + let reconveyance: JSONNull? + let registership: JSONNull? + let rhyacolite: JSONNull? + let smithereens: JSONNull? + let superedification: JSONNull? + let trust: JSONNull? + let whitestone: JSONNull? + + enum CodingKeys: String, CodingKey { + case blaspheme = "blaspheme" + case catharticalness = "catharticalness" + case celiosalpingectomy = "celiosalpingectomy" + case chirotherium = "Chirotherium" + case consummativeness = "consummativeness" + case disdiapason = "disdiapason" + case egestive = "egestive" + case enchylema = "enchylema" + case gasconade = "gasconade" + case holidayer = "holidayer" + case homocerc = "homocerc" + case intuitionalism = "intuitionalism" + case lophiostomate = "lophiostomate" + case nonbookish = "nonbookish" + case nonvolition = "nonvolition" + case palatableness = "palatableness" + case pimpery = "pimpery" + case previolation = "previolation" + case reconveyance = "reconveyance" + case registership = "registership" + case rhyacolite = "rhyacolite" + case smithereens = "smithereens" + case superedification = "superedification" + case trust = "trust" + case whitestone = "whitestone" + } +} + +// MARK: MonotheisticallyClass convenience initializers and mutators + +extension MonotheisticallyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + blaspheme: JSONNull?? = nil, + catharticalness: Double?? = nil, + celiosalpingectomy: JSONNull?? = nil, + chirotherium: Int?? = nil, + consummativeness: JSONNull?? = nil, + disdiapason: String?? = nil, + egestive: JSONNull?? = nil, + enchylema: JSONNull?? = nil, + gasconade: JSONNull?? = nil, + holidayer: JSONNull?? = nil, + homocerc: Bool?? = nil, + intuitionalism: JSONNull?? = nil, + lophiostomate: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nonvolition: JSONNull?? = nil, + palatableness: JSONNull?? = nil, + pimpery: JSONNull?? = nil, + previolation: JSONNull?? = nil, + reconveyance: JSONNull?? = nil, + registership: JSONNull?? = nil, + rhyacolite: JSONNull?? = nil, + smithereens: JSONNull?? = nil, + superedification: JSONNull?? = nil, + trust: JSONNull?? = nil, + whitestone: JSONNull?? = nil + ) -> MonotheisticallyClass { + return MonotheisticallyClass( + blaspheme: blaspheme ?? self.blaspheme, + catharticalness: catharticalness ?? self.catharticalness, + celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy, + chirotherium: chirotherium ?? self.chirotherium, + consummativeness: consummativeness ?? self.consummativeness, + disdiapason: disdiapason ?? self.disdiapason, + egestive: egestive ?? self.egestive, + enchylema: enchylema ?? self.enchylema, + gasconade: gasconade ?? self.gasconade, + holidayer: holidayer ?? self.holidayer, + homocerc: homocerc ?? self.homocerc, + intuitionalism: intuitionalism ?? self.intuitionalism, + lophiostomate: lophiostomate ?? self.lophiostomate, + nonbookish: nonbookish ?? self.nonbookish, + nonvolition: nonvolition ?? self.nonvolition, + palatableness: palatableness ?? self.palatableness, + pimpery: pimpery ?? self.pimpery, + previolation: previolation ?? self.previolation, + reconveyance: reconveyance ?? self.reconveyance, + registership: registership ?? self.registership, + rhyacolite: rhyacolite ?? self.rhyacolite, + smithereens: smithereens ?? self.smithereens, + superedification: superedification ?? self.superedification, + trust: trust ?? self.trust, + whitestone: whitestone ?? self.whitestone + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Montage: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Moralness: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Mulishly: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Myoscope: Codable, Sendable { + case bool(Bool) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Neuromastic: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - Noncontributing +struct Noncontributing: Codable, Sendable { + let estevin: String + let jolterhead: Double + let sauternes: Int + let sparsely: Bool + let unrequested: JSONNull? + + enum CodingKeys: String, CodingKey { + case estevin = "estevin" + case jolterhead = "jolterhead" + case sauternes = "sauternes" + case sparsely = "sparsely" + case unrequested = "unrequested" + } +} + +// MARK: Noncontributing convenience initializers and mutators + +extension Noncontributing { + init(data: Data) throws { + self = try newJSONDecoder().decode(Noncontributing.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + estevin: String? = nil, + jolterhead: Double? = nil, + sauternes: Int? = nil, + sparsely: Bool? = nil, + unrequested: JSONNull?? = nil + ) -> Noncontributing { + return Noncontributing( + estevin: estevin ?? self.estevin, + jolterhead: jolterhead ?? self.jolterhead, + sauternes: sauternes ?? self.sauternes, + sparsely: sparsely ?? self.sparsely, + unrequested: unrequested ?? self.unrequested + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Nonnervous: Codable, Sendable { + case bool(Bool) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Nonvaluation: Codable, Sendable { + case bool(Bool) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum OccupationalistElement: Codable, Sendable { + case nullArray([JSONNull?]) + case occupationalistClass(OccupationalistClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(OccupationalistClass.self) { + self = .occupationalistClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .occupationalistClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - OccupationalistClass +struct OccupationalistClass: Codable, Sendable { + let beholdable: JSONNull? + let brotuliform: JSONNull? + let chimakum: JSONNull? + let doodler: JSONNull? + let emulsin: JSONNull? + let fin: JSONNull? + let flourishing: JSONNull? + let flueless: JSONNull? + let furtively: JSONNull? + let gritter: JSONNull? + let interwish: JSONNull? + let monoxylic: JSONNull? + let myristic: JSONNull? + let nightwear: JSONNull? + let peruser: JSONNull? + let theoastrological: JSONNull? + let thumby: JSONNull? + let tingitid: JSONNull? + let trailless: JSONNull? + let unpocketed: JSONNull? + + enum CodingKeys: String, CodingKey { + case beholdable = "beholdable" + case brotuliform = "brotuliform" + case chimakum = "Chimakum" + case doodler = "doodler" + case emulsin = "emulsin" + case fin = "Fin" + case flourishing = "flourishing" + case flueless = "flueless" + case furtively = "furtively" + case gritter = "gritter" + case interwish = "interwish" + case monoxylic = "monoxylic" + case myristic = "myristic" + case nightwear = "nightwear" + case peruser = "peruser" + case theoastrological = "theoastrological" + case thumby = "thumby" + case tingitid = "tingitid" + case trailless = "trailless" + case unpocketed = "unpocketed" + } +} + +// MARK: OccupationalistClass convenience initializers and mutators + +extension OccupationalistClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(OccupationalistClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + beholdable: JSONNull?? = nil, + brotuliform: JSONNull?? = nil, + chimakum: JSONNull?? = nil, + doodler: JSONNull?? = nil, + emulsin: JSONNull?? = nil, + fin: JSONNull?? = nil, + flourishing: JSONNull?? = nil, + flueless: JSONNull?? = nil, + furtively: JSONNull?? = nil, + gritter: JSONNull?? = nil, + interwish: JSONNull?? = nil, + monoxylic: JSONNull?? = nil, + myristic: JSONNull?? = nil, + nightwear: JSONNull?? = nil, + peruser: JSONNull?? = nil, + theoastrological: JSONNull?? = nil, + thumby: JSONNull?? = nil, + tingitid: JSONNull?? = nil, + trailless: JSONNull?? = nil, + unpocketed: JSONNull?? = nil + ) -> OccupationalistClass { + return OccupationalistClass( + beholdable: beholdable ?? self.beholdable, + brotuliform: brotuliform ?? self.brotuliform, + chimakum: chimakum ?? self.chimakum, + doodler: doodler ?? self.doodler, + emulsin: emulsin ?? self.emulsin, + fin: fin ?? self.fin, + flourishing: flourishing ?? self.flourishing, + flueless: flueless ?? self.flueless, + furtively: furtively ?? self.furtively, + gritter: gritter ?? self.gritter, + interwish: interwish ?? self.interwish, + monoxylic: monoxylic ?? self.monoxylic, + myristic: myristic ?? self.myristic, + nightwear: nightwear ?? self.nightwear, + peruser: peruser ?? self.peruser, + theoastrological: theoastrological ?? self.theoastrological, + thumby: thumby ?? self.thumby, + tingitid: tingitid ?? self.tingitid, + trailless: trailless ?? self.trailless, + unpocketed: unpocketed ?? self.unpocketed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OutrivalElement: Codable, Sendable { + case double(Double) + case outrivalClass(OutrivalClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(OutrivalClass.self) { + self = .outrivalClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .outrivalClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - OutrivalClass +struct OutrivalClass: Codable, Sendable { + let adroitly: JSONNull? + let bridehood: JSONNull? + let castoroides: JSONNull? + let czechoslovak: JSONNull? + let diagenesis: JSONNull? + let dihexahedron: JSONNull? + let dopester: JSONNull? + let eumerism: JSONNull? + let flyness: JSONNull? + let fouler: JSONNull? + let laudanosine: JSONNull? + let lingulidae: JSONNull? + let minutary: JSONNull? + let mitra: JSONNull? + let opisthorchiasis: JSONNull? + let pensively: JSONNull? + let pubigerous: JSONNull? + let rebellious: JSONNull? + let recodify: JSONNull? + let unpaced: JSONNull? + + enum CodingKeys: String, CodingKey { + case adroitly = "adroitly" + case bridehood = "bridehood" + case castoroides = "Castoroides" + case czechoslovak = "Czechoslovak" + case diagenesis = "diagenesis" + case dihexahedron = "dihexahedron" + case dopester = "dopester" + case eumerism = "eumerism" + case flyness = "flyness" + case fouler = "fouler" + case laudanosine = "laudanosine" + case lingulidae = "Lingulidae" + case minutary = "minutary" + case mitra = "mitra" + case opisthorchiasis = "opisthorchiasis" + case pensively = "pensively" + case pubigerous = "pubigerous" + case rebellious = "rebellious" + case recodify = "recodify" + case unpaced = "unpaced" + } +} + +// MARK: OutrivalClass convenience initializers and mutators + +extension OutrivalClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(OutrivalClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adroitly: JSONNull?? = nil, + bridehood: JSONNull?? = nil, + castoroides: JSONNull?? = nil, + czechoslovak: JSONNull?? = nil, + diagenesis: JSONNull?? = nil, + dihexahedron: JSONNull?? = nil, + dopester: JSONNull?? = nil, + eumerism: JSONNull?? = nil, + flyness: JSONNull?? = nil, + fouler: JSONNull?? = nil, + laudanosine: JSONNull?? = nil, + lingulidae: JSONNull?? = nil, + minutary: JSONNull?? = nil, + mitra: JSONNull?? = nil, + opisthorchiasis: JSONNull?? = nil, + pensively: JSONNull?? = nil, + pubigerous: JSONNull?? = nil, + rebellious: JSONNull?? = nil, + recodify: JSONNull?? = nil, + unpaced: JSONNull?? = nil + ) -> OutrivalClass { + return OutrivalClass( + adroitly: adroitly ?? self.adroitly, + bridehood: bridehood ?? self.bridehood, + castoroides: castoroides ?? self.castoroides, + czechoslovak: czechoslovak ?? self.czechoslovak, + diagenesis: diagenesis ?? self.diagenesis, + dihexahedron: dihexahedron ?? self.dihexahedron, + dopester: dopester ?? self.dopester, + eumerism: eumerism ?? self.eumerism, + flyness: flyness ?? self.flyness, + fouler: fouler ?? self.fouler, + laudanosine: laudanosine ?? self.laudanosine, + lingulidae: lingulidae ?? self.lingulidae, + minutary: minutary ?? self.minutary, + mitra: mitra ?? self.mitra, + opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis, + pensively: pensively ?? self.pensively, + pubigerous: pubigerous ?? self.pubigerous, + rebellious: rebellious ?? self.rebellious, + recodify: recodify ?? self.recodify, + unpaced: unpaced ?? self.unpaced + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Paleographically: Codable, Sendable { + case double(Double) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Pamphletwise: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Pediatric: Codable, Sendable { + case bool(Bool) + case double(Double) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PiaculumElement: Codable, Sendable { + case double(Double) + case piaculumClass(PiaculumClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PiaculumClass.self) { + self = .piaculumClass(x) + return + } + throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .piaculumClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PiaculumClass +struct PiaculumClass: Codable, Sendable { + let alada: Int? + let amphistomous: Int? + let boysenberry: Int? + let catharticalness: Double? + let chirotherium: Int? + let decardinalize: Int? + let discouragement: Int? + let disdiapason: String? + let doitrified: Int? + let hexaspermous: Int? + let homocerc: Bool? + let insinking: Int? + let loathfulness: Int? + let miasmatical: Int? + let neurofibril: Int? + let nonbookish: JSONNull? + let phonendoscope: Int? + let pilferment: Int? + let predismissory: Int? + let preinscription: Int? + let quotative: Int? + let sienna: Int? + let thorax: Int? + let yachting: Int? + let zipper: Int? + + enum CodingKeys: String, CodingKey { + case alada = "alada" + case amphistomous = "amphistomous" + case boysenberry = "boysenberry" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case decardinalize = "decardinalize" + case discouragement = "discouragement" + case disdiapason = "disdiapason" + case doitrified = "doitrified" + case hexaspermous = "hexaspermous" + case homocerc = "homocerc" + case insinking = "insinking" + case loathfulness = "loathfulness" + case miasmatical = "miasmatical" + case neurofibril = "neurofibril" + case nonbookish = "nonbookish" + case phonendoscope = "phonendoscope" + case pilferment = "pilferment" + case predismissory = "predismissory" + case preinscription = "preinscription" + case quotative = "quotative" + case sienna = "sienna" + case thorax = "thorax" + case yachting = "yachting" + case zipper = "Zipper" + } +} + +// MARK: PiaculumClass convenience initializers and mutators + +extension PiaculumClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PiaculumClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alada: Int?? = nil, + amphistomous: Int?? = nil, + boysenberry: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + decardinalize: Int?? = nil, + discouragement: Int?? = nil, + disdiapason: String?? = nil, + doitrified: Int?? = nil, + hexaspermous: Int?? = nil, + homocerc: Bool?? = nil, + insinking: Int?? = nil, + loathfulness: Int?? = nil, + miasmatical: Int?? = nil, + neurofibril: Int?? = nil, + nonbookish: JSONNull?? = nil, + phonendoscope: Int?? = nil, + pilferment: Int?? = nil, + predismissory: Int?? = nil, + preinscription: Int?? = nil, + quotative: Int?? = nil, + sienna: Int?? = nil, + thorax: Int?? = nil, + yachting: Int?? = nil, + zipper: Int?? = nil + ) -> PiaculumClass { + return PiaculumClass( + alada: alada ?? self.alada, + amphistomous: amphistomous ?? self.amphistomous, + boysenberry: boysenberry ?? self.boysenberry, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + decardinalize: decardinalize ?? self.decardinalize, + discouragement: discouragement ?? self.discouragement, + disdiapason: disdiapason ?? self.disdiapason, + doitrified: doitrified ?? self.doitrified, + hexaspermous: hexaspermous ?? self.hexaspermous, + homocerc: homocerc ?? self.homocerc, + insinking: insinking ?? self.insinking, + loathfulness: loathfulness ?? self.loathfulness, + miasmatical: miasmatical ?? self.miasmatical, + neurofibril: neurofibril ?? self.neurofibril, + nonbookish: nonbookish ?? self.nonbookish, + phonendoscope: phonendoscope ?? self.phonendoscope, + pilferment: pilferment ?? self.pilferment, + predismissory: predismissory ?? self.predismissory, + preinscription: preinscription ?? self.preinscription, + quotative: quotative ?? self.quotative, + sienna: sienna ?? self.sienna, + thorax: thorax ?? self.thorax, + yachting: yachting ?? self.yachting, + zipper: zipper ?? self.zipper + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Piccadilly: Codable, Sendable { + case double(Double) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Piffler: Codable, Sendable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Pithful: Codable, Sendable { + case bool(Bool) + case integer(Int) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Placuntiti: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Plectopterous: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Pneumocele +struct Pneumocele: Codable, Sendable { + let carbonarism: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let cineolic: JSONNull? + let cobbly: JSONNull? + let conchyliferous: JSONNull? + let congregation: JSONNull? + let disdiapason: String? + let enterotomy: JSONNull? + let entophytal: JSONNull? + let fewtrils: JSONNull? + let herem: JSONNull? + let homocerc: Bool? + let koniga: JSONNull? + let meticulosity: JSONNull? + let micky: JSONNull? + let mismarriage: JSONNull? + let neurotrophic: JSONNull? + let nonbookish: JSONNull? + let persuasively: JSONNull? + let replaceable: JSONNull? + let silex: JSONNull? + let taillight: JSONNull? + let unjealous: JSONNull? + let visitorial: JSONNull? + + enum CodingKeys: String, CodingKey { + case carbonarism = "Carbonarism" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cineolic = "cineolic" + case cobbly = "cobbly" + case conchyliferous = "conchyliferous" + case congregation = "congregation" + case disdiapason = "disdiapason" + case enterotomy = "enterotomy" + case entophytal = "entophytal" + case fewtrils = "fewtrils" + case herem = "herem" + case homocerc = "homocerc" + case koniga = "Koniga" + case meticulosity = "meticulosity" + case micky = "Micky" + case mismarriage = "mismarriage" + case neurotrophic = "neurotrophic" + case nonbookish = "nonbookish" + case persuasively = "persuasively" + case replaceable = "replaceable" + case silex = "silex" + case taillight = "taillight" + case unjealous = "unjealous" + case visitorial = "visitorial" + } +} + +// MARK: Pneumocele convenience initializers and mutators + +extension Pneumocele { + init(data: Data) throws { + self = try newJSONDecoder().decode(Pneumocele.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + carbonarism: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cineolic: JSONNull?? = nil, + cobbly: JSONNull?? = nil, + conchyliferous: JSONNull?? = nil, + congregation: JSONNull?? = nil, + disdiapason: String?? = nil, + enterotomy: JSONNull?? = nil, + entophytal: JSONNull?? = nil, + fewtrils: JSONNull?? = nil, + herem: JSONNull?? = nil, + homocerc: Bool?? = nil, + koniga: JSONNull?? = nil, + meticulosity: JSONNull?? = nil, + micky: JSONNull?? = nil, + mismarriage: JSONNull?? = nil, + neurotrophic: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + persuasively: JSONNull?? = nil, + replaceable: JSONNull?? = nil, + silex: JSONNull?? = nil, + taillight: JSONNull?? = nil, + unjealous: JSONNull?? = nil, + visitorial: JSONNull?? = nil + ) -> Pneumocele { + return Pneumocele( + carbonarism: carbonarism ?? self.carbonarism, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cineolic: cineolic ?? self.cineolic, + cobbly: cobbly ?? self.cobbly, + conchyliferous: conchyliferous ?? self.conchyliferous, + congregation: congregation ?? self.congregation, + disdiapason: disdiapason ?? self.disdiapason, + enterotomy: enterotomy ?? self.enterotomy, + entophytal: entophytal ?? self.entophytal, + fewtrils: fewtrils ?? self.fewtrils, + herem: herem ?? self.herem, + homocerc: homocerc ?? self.homocerc, + koniga: koniga ?? self.koniga, + meticulosity: meticulosity ?? self.meticulosity, + micky: micky ?? self.micky, + mismarriage: mismarriage ?? self.mismarriage, + neurotrophic: neurotrophic ?? self.neurotrophic, + nonbookish: nonbookish ?? self.nonbookish, + persuasively: persuasively ?? self.persuasively, + replaceable: replaceable ?? self.replaceable, + silex: silex ?? self.silex, + taillight: taillight ?? self.taillight, + unjealous: unjealous ?? self.unjealous, + visitorial: visitorial ?? self.visitorial + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Poliorcetic: Codable, Sendable { + case bool(Bool) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Poormaster: Codable, Sendable { + case integerArray([Int]) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PotwhiskyElement: Codable, Sendable { + case integer(Int) + case potwhiskyClass(PotwhiskyClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PotwhiskyClass.self) { + self = .potwhiskyClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .potwhiskyClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - PotwhiskyClass +struct PotwhiskyClass: Codable, Sendable { + let arciform: JSONNull? + let cresolin: JSONNull? + let disheartener: JSONNull? + let disproportionable: JSONNull? + let euchorda: JSONNull? + let ferryway: JSONNull? + let filamentiferous: JSONNull? + let flemish: JSONNull? + let forgainst: JSONNull? + let grainering: JSONNull? + let irrevoluble: JSONNull? + let kindredship: JSONNull? + let pinguitudinous: JSONNull? + let simpletonic: JSONNull? + let singsong: JSONNull? + let submergement: JSONNull? + let supraoesophagal: JSONNull? + let thrashel: JSONNull? + let tyremesis: JSONNull? + let yoruba: JSONNull? + + enum CodingKeys: String, CodingKey { + case arciform = "arciform" + case cresolin = "cresolin" + case disheartener = "disheartener" + case disproportionable = "disproportionable" + case euchorda = "Euchorda" + case ferryway = "ferryway" + case filamentiferous = "filamentiferous" + case flemish = "flemish" + case forgainst = "forgainst" + case grainering = "grainering" + case irrevoluble = "irrevoluble" + case kindredship = "kindredship" + case pinguitudinous = "pinguitudinous" + case simpletonic = "simpletonic" + case singsong = "singsong" + case submergement = "submergement" + case supraoesophagal = "supraoesophagal" + case thrashel = "thrashel" + case tyremesis = "tyremesis" + case yoruba = "Yoruba" + } +} + +// MARK: PotwhiskyClass convenience initializers and mutators + +extension PotwhiskyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PotwhiskyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + arciform: JSONNull?? = nil, + cresolin: JSONNull?? = nil, + disheartener: JSONNull?? = nil, + disproportionable: JSONNull?? = nil, + euchorda: JSONNull?? = nil, + ferryway: JSONNull?? = nil, + filamentiferous: JSONNull?? = nil, + flemish: JSONNull?? = nil, + forgainst: JSONNull?? = nil, + grainering: JSONNull?? = nil, + irrevoluble: JSONNull?? = nil, + kindredship: JSONNull?? = nil, + pinguitudinous: JSONNull?? = nil, + simpletonic: JSONNull?? = nil, + singsong: JSONNull?? = nil, + submergement: JSONNull?? = nil, + supraoesophagal: JSONNull?? = nil, + thrashel: JSONNull?? = nil, + tyremesis: JSONNull?? = nil, + yoruba: JSONNull?? = nil + ) -> PotwhiskyClass { + return PotwhiskyClass( + arciform: arciform ?? self.arciform, + cresolin: cresolin ?? self.cresolin, + disheartener: disheartener ?? self.disheartener, + disproportionable: disproportionable ?? self.disproportionable, + euchorda: euchorda ?? self.euchorda, + ferryway: ferryway ?? self.ferryway, + filamentiferous: filamentiferous ?? self.filamentiferous, + flemish: flemish ?? self.flemish, + forgainst: forgainst ?? self.forgainst, + grainering: grainering ?? self.grainering, + irrevoluble: irrevoluble ?? self.irrevoluble, + kindredship: kindredship ?? self.kindredship, + pinguitudinous: pinguitudinous ?? self.pinguitudinous, + simpletonic: simpletonic ?? self.simpletonic, + singsong: singsong ?? self.singsong, + submergement: submergement ?? self.submergement, + supraoesophagal: supraoesophagal ?? self.supraoesophagal, + thrashel: thrashel ?? self.thrashel, + tyremesis: tyremesis ?? self.tyremesis, + yoruba: yoruba ?? self.yoruba + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Practicalizer: Codable, Sendable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum PrefreshmanElement: Codable, Sendable { + case nullArray([JSONNull?]) + case prefreshmanClass(PrefreshmanClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(PrefreshmanClass.self) { + self = .prefreshmanClass(x) + return + } + throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .prefreshmanClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - PrefreshmanClass +struct PrefreshmanClass: Codable, Sendable { + let azorubine: JSONNull? + let choroiditis: JSONNull? + let coagulatory: JSONNull? + let cyclorama: JSONNull? + let dolphus: JSONNull? + let duckhearted: JSONNull? + let ficus: JSONNull? + let gemaric: JSONNull? + let jugation: JSONNull? + let myoliposis: JSONNull? + let nonnomination: JSONNull? + let palay: JSONNull? + let pentactinal: JSONNull? + let phaet: JSONNull? + let piquant: JSONNull? + let registration: JSONNull? + let remancipation: JSONNull? + let scutatiform: JSONNull? + let theodolite: JSONNull? + let underward: JSONNull? + + enum CodingKeys: String, CodingKey { + case azorubine = "azorubine" + case choroiditis = "choroiditis" + case coagulatory = "coagulatory" + case cyclorama = "cyclorama" + case dolphus = "Dolphus" + case duckhearted = "duckhearted" + case ficus = "Ficus" + case gemaric = "Gemaric" + case jugation = "jugation" + case myoliposis = "myoliposis" + case nonnomination = "nonnomination" + case palay = "palay" + case pentactinal = "pentactinal" + case phaet = "Phaet" + case piquant = "piquant" + case registration = "registration" + case remancipation = "remancipation" + case scutatiform = "scutatiform" + case theodolite = "theodolite" + case underward = "underward" + } +} + +// MARK: PrefreshmanClass convenience initializers and mutators + +extension PrefreshmanClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PrefreshmanClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + azorubine: JSONNull?? = nil, + choroiditis: JSONNull?? = nil, + coagulatory: JSONNull?? = nil, + cyclorama: JSONNull?? = nil, + dolphus: JSONNull?? = nil, + duckhearted: JSONNull?? = nil, + ficus: JSONNull?? = nil, + gemaric: JSONNull?? = nil, + jugation: JSONNull?? = nil, + myoliposis: JSONNull?? = nil, + nonnomination: JSONNull?? = nil, + palay: JSONNull?? = nil, + pentactinal: JSONNull?? = nil, + phaet: JSONNull?? = nil, + piquant: JSONNull?? = nil, + registration: JSONNull?? = nil, + remancipation: JSONNull?? = nil, + scutatiform: JSONNull?? = nil, + theodolite: JSONNull?? = nil, + underward: JSONNull?? = nil + ) -> PrefreshmanClass { + return PrefreshmanClass( + azorubine: azorubine ?? self.azorubine, + choroiditis: choroiditis ?? self.choroiditis, + coagulatory: coagulatory ?? self.coagulatory, + cyclorama: cyclorama ?? self.cyclorama, + dolphus: dolphus ?? self.dolphus, + duckhearted: duckhearted ?? self.duckhearted, + ficus: ficus ?? self.ficus, + gemaric: gemaric ?? self.gemaric, + jugation: jugation ?? self.jugation, + myoliposis: myoliposis ?? self.myoliposis, + nonnomination: nonnomination ?? self.nonnomination, + palay: palay ?? self.palay, + pentactinal: pentactinal ?? self.pentactinal, + phaet: phaet ?? self.phaet, + piquant: piquant ?? self.piquant, + registration: registration ?? self.registration, + remancipation: remancipation ?? self.remancipation, + scutatiform: scutatiform ?? self.scutatiform, + theodolite: theodolite ?? self.theodolite, + underward: underward ?? self.underward + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Prehensility: Codable, Sendable { + case bool(Bool) + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Prevoidance: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Protext: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations3.json/struct-or-class-class--238d6c8a12d4/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations3.json/struct-or-class-class--238d6c8a12d4/quicktype.swift new file mode 100644 index 0000000..16a375b --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations3.json/struct-or-class-class--238d6c8a12d4/quicktype.swift @@ -0,0 +1,3534 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable, Sendable { + let juror: [JurorElement] + let kongoni: [Kongoni] + let ladronism: [LadronismElement] + let landlubberly: [LandlubberlyElement] + let listener: [Listener] + let lupus: [LupusElement] + let maslin: [Maslin] + let monazite: [MonaziteElement] + let monoliteral: [Monoliteral] + let monotheistically: [MonotheisticallyElement] + let montage: [Montage] + let moralness: [Moralness] + let mowra: [MonaziteClass?] + let mulishly: [Mulishly] + let myoscope: [Myoscope] + let nach: [[Int?]?] + let neuromastic: [Neuromastic] + let noncontributing: [Noncontributing] + let nonnervous: [Nonnervous] + let nonvaluation: [Nonvaluation] + let occupationalist: [OccupationalistElement] + let outrival: [OutrivalElement] + let paleographically: [Paleographically] + let pamphletwise: [Pamphletwise] + let pediatrics: [Pediatric] + let perceptive: [Bool] + let piaculum: [PiaculumElement] + let piccadilly: [Piccadilly] + let piffler: [Piffler] + let pithful: [Pithful] + let placuntitis: [Placuntiti] + let plectopterous: [Plectopterous] + let pneumocele: [Pneumocele?] + let poliorcetic: [Poliorcetic] + let poormaster: [Poormaster] + let potwhisky: [PotwhiskyElement] + let practicalizer: [Practicalizer] + let prefreshman: [PrefreshmanElement] + let prehensility: [Prehensility] + let prevoidance: [Prevoidance] + let probant: [[String: Int?]] + let protext: [Protext] + + enum CodingKeys: String, CodingKey { + case juror = "juror" + case kongoni = "kongoni" + case ladronism = "ladronism" + case landlubberly = "landlubberly" + case listener = "listener" + case lupus = "lupus" + case maslin = "maslin" + case monazite = "monazite" + case monoliteral = "monoliteral" + case monotheistically = "monotheistically" + case montage = "montage" + case moralness = "moralness" + case mowra = "mowra" + case mulishly = "mulishly" + case myoscope = "myoscope" + case nach = "nach" + case neuromastic = "neuromastic" + case noncontributing = "noncontributing" + case nonnervous = "nonnervous" + case nonvaluation = "nonvaluation" + case occupationalist = "occupationalist" + case outrival = "outrival" + case paleographically = "paleographically" + case pamphletwise = "pamphletwise" + case pediatrics = "pediatrics" + case perceptive = "perceptive" + case piaculum = "piaculum" + case piccadilly = "piccadilly" + case piffler = "piffler" + case pithful = "pithful" + case placuntitis = "placuntitis" + case plectopterous = "plectopterous" + case pneumocele = "pneumocele" + case poliorcetic = "poliorcetic" + case poormaster = "poormaster" + case potwhisky = "potwhisky" + case practicalizer = "practicalizer" + case prefreshman = "prefreshman" + case prehensility = "prehensility" + case prevoidance = "prevoidance" + case probant = "probant" + case protext = "protext" + } + + init(juror: [JurorElement], kongoni: [Kongoni], ladronism: [LadronismElement], landlubberly: [LandlubberlyElement], listener: [Listener], lupus: [LupusElement], maslin: [Maslin], monazite: [MonaziteElement], monoliteral: [Monoliteral], monotheistically: [MonotheisticallyElement], montage: [Montage], moralness: [Moralness], mowra: [MonaziteClass?], mulishly: [Mulishly], myoscope: [Myoscope], nach: [[Int?]?], neuromastic: [Neuromastic], noncontributing: [Noncontributing], nonnervous: [Nonnervous], nonvaluation: [Nonvaluation], occupationalist: [OccupationalistElement], outrival: [OutrivalElement], paleographically: [Paleographically], pamphletwise: [Pamphletwise], pediatrics: [Pediatric], perceptive: [Bool], piaculum: [PiaculumElement], piccadilly: [Piccadilly], piffler: [Piffler], pithful: [Pithful], placuntitis: [Placuntiti], plectopterous: [Plectopterous], pneumocele: [Pneumocele?], poliorcetic: [Poliorcetic], poormaster: [Poormaster], potwhisky: [PotwhiskyElement], practicalizer: [Practicalizer], prefreshman: [PrefreshmanElement], prehensility: [Prehensility], prevoidance: [Prevoidance], probant: [[String: Int?]], protext: [Protext]) { + self.juror = juror + self.kongoni = kongoni + self.ladronism = ladronism + self.landlubberly = landlubberly + self.listener = listener + self.lupus = lupus + self.maslin = maslin + self.monazite = monazite + self.monoliteral = monoliteral + self.monotheistically = monotheistically + self.montage = montage + self.moralness = moralness + self.mowra = mowra + self.mulishly = mulishly + self.myoscope = myoscope + self.nach = nach + self.neuromastic = neuromastic + self.noncontributing = noncontributing + self.nonnervous = nonnervous + self.nonvaluation = nonvaluation + self.occupationalist = occupationalist + self.outrival = outrival + self.paleographically = paleographically + self.pamphletwise = pamphletwise + self.pediatrics = pediatrics + self.perceptive = perceptive + self.piaculum = piaculum + self.piccadilly = piccadilly + self.piffler = piffler + self.pithful = pithful + self.placuntitis = placuntitis + self.plectopterous = plectopterous + self.pneumocele = pneumocele + self.poliorcetic = poliorcetic + self.poormaster = poormaster + self.potwhisky = potwhisky + self.practicalizer = practicalizer + self.prefreshman = prefreshman + self.prehensility = prehensility + self.prevoidance = prevoidance + self.probant = probant + self.protext = protext + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(juror: me.juror, kongoni: me.kongoni, ladronism: me.ladronism, landlubberly: me.landlubberly, listener: me.listener, lupus: me.lupus, maslin: me.maslin, monazite: me.monazite, monoliteral: me.monoliteral, monotheistically: me.monotheistically, montage: me.montage, moralness: me.moralness, mowra: me.mowra, mulishly: me.mulishly, myoscope: me.myoscope, nach: me.nach, neuromastic: me.neuromastic, noncontributing: me.noncontributing, nonnervous: me.nonnervous, nonvaluation: me.nonvaluation, occupationalist: me.occupationalist, outrival: me.outrival, paleographically: me.paleographically, pamphletwise: me.pamphletwise, pediatrics: me.pediatrics, perceptive: me.perceptive, piaculum: me.piaculum, piccadilly: me.piccadilly, piffler: me.piffler, pithful: me.pithful, placuntitis: me.placuntitis, plectopterous: me.plectopterous, pneumocele: me.pneumocele, poliorcetic: me.poliorcetic, poormaster: me.poormaster, potwhisky: me.potwhisky, practicalizer: me.practicalizer, prefreshman: me.prefreshman, prehensility: me.prehensility, prevoidance: me.prevoidance, probant: me.probant, protext: me.protext) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + juror: [JurorElement]? = nil, + kongoni: [Kongoni]? = nil, + ladronism: [LadronismElement]? = nil, + landlubberly: [LandlubberlyElement]? = nil, + listener: [Listener]? = nil, + lupus: [LupusElement]? = nil, + maslin: [Maslin]? = nil, + monazite: [MonaziteElement]? = nil, + monoliteral: [Monoliteral]? = nil, + monotheistically: [MonotheisticallyElement]? = nil, + montage: [Montage]? = nil, + moralness: [Moralness]? = nil, + mowra: [MonaziteClass?]? = nil, + mulishly: [Mulishly]? = nil, + myoscope: [Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [Neuromastic]? = nil, + noncontributing: [Noncontributing]? = nil, + nonnervous: [Nonnervous]? = nil, + nonvaluation: [Nonvaluation]? = nil, + occupationalist: [OccupationalistElement]? = nil, + outrival: [OutrivalElement]? = nil, + paleographically: [Paleographically]? = nil, + pamphletwise: [Pamphletwise]? = nil, + pediatrics: [Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [PiaculumElement]? = nil, + piccadilly: [Piccadilly]? = nil, + piffler: [Piffler]? = nil, + pithful: [Pithful]? = nil, + placuntitis: [Placuntiti]? = nil, + plectopterous: [Plectopterous]? = nil, + pneumocele: [Pneumocele?]? = nil, + poliorcetic: [Poliorcetic]? = nil, + poormaster: [Poormaster]? = nil, + potwhisky: [PotwhiskyElement]? = nil, + practicalizer: [Practicalizer]? = nil, + prefreshman: [PrefreshmanElement]? = nil, + prehensility: [Prehensility]? = nil, + prevoidance: [Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [Protext]? = nil + ) -> TopLevel { + return TopLevel( + juror: juror ?? self.juror, + kongoni: kongoni ?? self.kongoni, + ladronism: ladronism ?? self.ladronism, + landlubberly: landlubberly ?? self.landlubberly, + listener: listener ?? self.listener, + lupus: lupus ?? self.lupus, + maslin: maslin ?? self.maslin, + monazite: monazite ?? self.monazite, + monoliteral: monoliteral ?? self.monoliteral, + monotheistically: monotheistically ?? self.monotheistically, + montage: montage ?? self.montage, + moralness: moralness ?? self.moralness, + mowra: mowra ?? self.mowra, + mulishly: mulishly ?? self.mulishly, + myoscope: myoscope ?? self.myoscope, + nach: nach ?? self.nach, + neuromastic: neuromastic ?? self.neuromastic, + noncontributing: noncontributing ?? self.noncontributing, + nonnervous: nonnervous ?? self.nonnervous, + nonvaluation: nonvaluation ?? self.nonvaluation, + occupationalist: occupationalist ?? self.occupationalist, + outrival: outrival ?? self.outrival, + paleographically: paleographically ?? self.paleographically, + pamphletwise: pamphletwise ?? self.pamphletwise, + pediatrics: pediatrics ?? self.pediatrics, + perceptive: perceptive ?? self.perceptive, + piaculum: piaculum ?? self.piaculum, + piccadilly: piccadilly ?? self.piccadilly, + piffler: piffler ?? self.piffler, + pithful: pithful ?? self.pithful, + placuntitis: placuntitis ?? self.placuntitis, + plectopterous: plectopterous ?? self.plectopterous, + pneumocele: pneumocele ?? self.pneumocele, + poliorcetic: poliorcetic ?? self.poliorcetic, + poormaster: poormaster ?? self.poormaster, + potwhisky: potwhisky ?? self.potwhisky, + practicalizer: practicalizer ?? self.practicalizer, + prefreshman: prefreshman ?? self.prefreshman, + prehensility: prehensility ?? self.prehensility, + prevoidance: prevoidance ?? self.prevoidance, + probant: probant ?? self.probant, + protext: protext ?? self.protext + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum JurorElement: Codable, Sendable { + case bool(Bool) + case jurorClass(JurorClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(JurorClass.self) { + self = .jurorClass(x) + return + } + throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .jurorClass(let x): + try container.encode(x) + } + } +} + +// MARK: - JurorClass +final class JurorClass: Codable, Sendable { + let adipsy: JSONNull? + let auxiliator: JSONNull? + let benda: JSONNull? + let benjamin: JSONNull? + let brandling: JSONNull? + let epicurishly: JSONNull? + let eremochaetous: JSONNull? + let marten: JSONNull? + let monocline: JSONNull? + let olea: JSONNull? + let palgat: JSONNull? + let pennyworth: JSONNull? + let pioury: JSONNull? + let pragmatistic: JSONNull? + let stylelessness: JSONNull? + let systematical: JSONNull? + let thready: JSONNull? + let uncontemporary: JSONNull? + let uncouched: JSONNull? + let uninhabitedness: JSONNull? + + enum CodingKeys: String, CodingKey { + case adipsy = "adipsy" + case auxiliator = "auxiliator" + case benda = "benda" + case benjamin = "benjamin" + case brandling = "brandling" + case epicurishly = "epicurishly" + case eremochaetous = "eremochaetous" + case marten = "marten" + case monocline = "monocline" + case olea = "Olea" + case palgat = "palgat" + case pennyworth = "pennyworth" + case pioury = "pioury" + case pragmatistic = "pragmatistic" + case stylelessness = "stylelessness" + case systematical = "systematical" + case thready = "thready" + case uncontemporary = "uncontemporary" + case uncouched = "uncouched" + case uninhabitedness = "uninhabitedness" + } + + init(adipsy: JSONNull?, auxiliator: JSONNull?, benda: JSONNull?, benjamin: JSONNull?, brandling: JSONNull?, epicurishly: JSONNull?, eremochaetous: JSONNull?, marten: JSONNull?, monocline: JSONNull?, olea: JSONNull?, palgat: JSONNull?, pennyworth: JSONNull?, pioury: JSONNull?, pragmatistic: JSONNull?, stylelessness: JSONNull?, systematical: JSONNull?, thready: JSONNull?, uncontemporary: JSONNull?, uncouched: JSONNull?, uninhabitedness: JSONNull?) { + self.adipsy = adipsy + self.auxiliator = auxiliator + self.benda = benda + self.benjamin = benjamin + self.brandling = brandling + self.epicurishly = epicurishly + self.eremochaetous = eremochaetous + self.marten = marten + self.monocline = monocline + self.olea = olea + self.palgat = palgat + self.pennyworth = pennyworth + self.pioury = pioury + self.pragmatistic = pragmatistic + self.stylelessness = stylelessness + self.systematical = systematical + self.thready = thready + self.uncontemporary = uncontemporary + self.uncouched = uncouched + self.uninhabitedness = uninhabitedness + } +} + +// MARK: JurorClass convenience initializers and mutators + +extension JurorClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(JurorClass.self, from: data) + self.init(adipsy: me.adipsy, auxiliator: me.auxiliator, benda: me.benda, benjamin: me.benjamin, brandling: me.brandling, epicurishly: me.epicurishly, eremochaetous: me.eremochaetous, marten: me.marten, monocline: me.monocline, olea: me.olea, palgat: me.palgat, pennyworth: me.pennyworth, pioury: me.pioury, pragmatistic: me.pragmatistic, stylelessness: me.stylelessness, systematical: me.systematical, thready: me.thready, uncontemporary: me.uncontemporary, uncouched: me.uncouched, uninhabitedness: me.uninhabitedness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adipsy: JSONNull?? = nil, + auxiliator: JSONNull?? = nil, + benda: JSONNull?? = nil, + benjamin: JSONNull?? = nil, + brandling: JSONNull?? = nil, + epicurishly: JSONNull?? = nil, + eremochaetous: JSONNull?? = nil, + marten: JSONNull?? = nil, + monocline: JSONNull?? = nil, + olea: JSONNull?? = nil, + palgat: JSONNull?? = nil, + pennyworth: JSONNull?? = nil, + pioury: JSONNull?? = nil, + pragmatistic: JSONNull?? = nil, + stylelessness: JSONNull?? = nil, + systematical: JSONNull?? = nil, + thready: JSONNull?? = nil, + uncontemporary: JSONNull?? = nil, + uncouched: JSONNull?? = nil, + uninhabitedness: JSONNull?? = nil + ) -> JurorClass { + return JurorClass( + adipsy: adipsy ?? self.adipsy, + auxiliator: auxiliator ?? self.auxiliator, + benda: benda ?? self.benda, + benjamin: benjamin ?? self.benjamin, + brandling: brandling ?? self.brandling, + epicurishly: epicurishly ?? self.epicurishly, + eremochaetous: eremochaetous ?? self.eremochaetous, + marten: marten ?? self.marten, + monocline: monocline ?? self.monocline, + olea: olea ?? self.olea, + palgat: palgat ?? self.palgat, + pennyworth: pennyworth ?? self.pennyworth, + pioury: pioury ?? self.pioury, + pragmatistic: pragmatistic ?? self.pragmatistic, + stylelessness: stylelessness ?? self.stylelessness, + systematical: systematical ?? self.systematical, + thready: thready ?? self.thready, + uncontemporary: uncontemporary ?? self.uncontemporary, + uncouched: uncouched ?? self.uncouched, + uninhabitedness: uninhabitedness ?? self.uninhabitedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Kongoni: Codable, Sendable { + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum LadronismElement: Codable, Sendable { + case double(Double) + case ladronismClass(LadronismClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LadronismClass.self) { + self = .ladronismClass(x) + return + } + throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .ladronismClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - LadronismClass +final class LadronismClass: Codable, Sendable { + let acclaimer: JSONNull? + let achree: JSONNull? + let base: JSONNull? + let conundrumize: JSONNull? + let degerminator: JSONNull? + let describable: JSONNull? + let exasperatedly: JSONNull? + let heroine: JSONNull? + let indazin: JSONNull? + let luteous: JSONNull? + let papular: JSONNull? + let pritch: JSONNull? + let prodenia: JSONNull? + let seege: JSONNull? + let shopgirl: JSONNull? + let tragedietta: JSONNull? + let unsparse: JSONNull? + let uplook: JSONNull? + let vermiformis: JSONNull? + let whafabout: JSONNull? + + enum CodingKeys: String, CodingKey { + case acclaimer = "acclaimer" + case achree = "achree" + case base = "base" + case conundrumize = "conundrumize" + case degerminator = "degerminator" + case describable = "describable" + case exasperatedly = "exasperatedly" + case heroine = "heroine" + case indazin = "indazin" + case luteous = "luteous" + case papular = "papular" + case pritch = "pritch" + case prodenia = "Prodenia" + case seege = "seege" + case shopgirl = "shopgirl" + case tragedietta = "tragedietta" + case unsparse = "unsparse" + case uplook = "uplook" + case vermiformis = "vermiformis" + case whafabout = "whafabout" + } + + init(acclaimer: JSONNull?, achree: JSONNull?, base: JSONNull?, conundrumize: JSONNull?, degerminator: JSONNull?, describable: JSONNull?, exasperatedly: JSONNull?, heroine: JSONNull?, indazin: JSONNull?, luteous: JSONNull?, papular: JSONNull?, pritch: JSONNull?, prodenia: JSONNull?, seege: JSONNull?, shopgirl: JSONNull?, tragedietta: JSONNull?, unsparse: JSONNull?, uplook: JSONNull?, vermiformis: JSONNull?, whafabout: JSONNull?) { + self.acclaimer = acclaimer + self.achree = achree + self.base = base + self.conundrumize = conundrumize + self.degerminator = degerminator + self.describable = describable + self.exasperatedly = exasperatedly + self.heroine = heroine + self.indazin = indazin + self.luteous = luteous + self.papular = papular + self.pritch = pritch + self.prodenia = prodenia + self.seege = seege + self.shopgirl = shopgirl + self.tragedietta = tragedietta + self.unsparse = unsparse + self.uplook = uplook + self.vermiformis = vermiformis + self.whafabout = whafabout + } +} + +// MARK: LadronismClass convenience initializers and mutators + +extension LadronismClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LadronismClass.self, from: data) + self.init(acclaimer: me.acclaimer, achree: me.achree, base: me.base, conundrumize: me.conundrumize, degerminator: me.degerminator, describable: me.describable, exasperatedly: me.exasperatedly, heroine: me.heroine, indazin: me.indazin, luteous: me.luteous, papular: me.papular, pritch: me.pritch, prodenia: me.prodenia, seege: me.seege, shopgirl: me.shopgirl, tragedietta: me.tragedietta, unsparse: me.unsparse, uplook: me.uplook, vermiformis: me.vermiformis, whafabout: me.whafabout) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acclaimer: JSONNull?? = nil, + achree: JSONNull?? = nil, + base: JSONNull?? = nil, + conundrumize: JSONNull?? = nil, + degerminator: JSONNull?? = nil, + describable: JSONNull?? = nil, + exasperatedly: JSONNull?? = nil, + heroine: JSONNull?? = nil, + indazin: JSONNull?? = nil, + luteous: JSONNull?? = nil, + papular: JSONNull?? = nil, + pritch: JSONNull?? = nil, + prodenia: JSONNull?? = nil, + seege: JSONNull?? = nil, + shopgirl: JSONNull?? = nil, + tragedietta: JSONNull?? = nil, + unsparse: JSONNull?? = nil, + uplook: JSONNull?? = nil, + vermiformis: JSONNull?? = nil, + whafabout: JSONNull?? = nil + ) -> LadronismClass { + return LadronismClass( + acclaimer: acclaimer ?? self.acclaimer, + achree: achree ?? self.achree, + base: base ?? self.base, + conundrumize: conundrumize ?? self.conundrumize, + degerminator: degerminator ?? self.degerminator, + describable: describable ?? self.describable, + exasperatedly: exasperatedly ?? self.exasperatedly, + heroine: heroine ?? self.heroine, + indazin: indazin ?? self.indazin, + luteous: luteous ?? self.luteous, + papular: papular ?? self.papular, + pritch: pritch ?? self.pritch, + prodenia: prodenia ?? self.prodenia, + seege: seege ?? self.seege, + shopgirl: shopgirl ?? self.shopgirl, + tragedietta: tragedietta ?? self.tragedietta, + unsparse: unsparse ?? self.unsparse, + uplook: uplook ?? self.uplook, + vermiformis: vermiformis ?? self.vermiformis, + whafabout: whafabout ?? self.whafabout + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum LandlubberlyElement: Codable, Sendable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(LandlubberlyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LandlubberlyClass.self) { + self = .landlubberlyClass(x) + return + } + throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .landlubberlyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - LandlubberlyClass +final class LandlubberlyClass: Codable, Sendable { + let acropoleis: JSONNull? + let aminate: JSONNull? + let amyraldism: JSONNull? + let bipenniform: JSONNull? + let bugre: JSONNull? + let calycule: JSONNull? + let caoutchouc: JSONNull? + let disprover: JSONNull? + let fitroot: JSONNull? + let fulgently: JSONNull? + let kickup: JSONNull? + let laevoversion: JSONNull? + let moter: JSONNull? + let objectivity: JSONNull? + let posterity: JSONNull? + let postnuptial: JSONNull? + let precedentary: JSONNull? + let saddling: JSONNull? + let subcurrent: JSONNull? + let unrecriminative: JSONNull? + + enum CodingKeys: String, CodingKey { + case acropoleis = "acropoleis" + case aminate = "aminate" + case amyraldism = "Amyraldism" + case bipenniform = "bipenniform" + case bugre = "bugre" + case calycule = "calycule" + case caoutchouc = "caoutchouc" + case disprover = "disprover" + case fitroot = "fitroot" + case fulgently = "fulgently" + case kickup = "kickup" + case laevoversion = "laevoversion" + case moter = "moter" + case objectivity = "objectivity" + case posterity = "posterity" + case postnuptial = "postnuptial" + case precedentary = "precedentary" + case saddling = "saddling" + case subcurrent = "subcurrent" + case unrecriminative = "unrecriminative" + } + + init(acropoleis: JSONNull?, aminate: JSONNull?, amyraldism: JSONNull?, bipenniform: JSONNull?, bugre: JSONNull?, calycule: JSONNull?, caoutchouc: JSONNull?, disprover: JSONNull?, fitroot: JSONNull?, fulgently: JSONNull?, kickup: JSONNull?, laevoversion: JSONNull?, moter: JSONNull?, objectivity: JSONNull?, posterity: JSONNull?, postnuptial: JSONNull?, precedentary: JSONNull?, saddling: JSONNull?, subcurrent: JSONNull?, unrecriminative: JSONNull?) { + self.acropoleis = acropoleis + self.aminate = aminate + self.amyraldism = amyraldism + self.bipenniform = bipenniform + self.bugre = bugre + self.calycule = calycule + self.caoutchouc = caoutchouc + self.disprover = disprover + self.fitroot = fitroot + self.fulgently = fulgently + self.kickup = kickup + self.laevoversion = laevoversion + self.moter = moter + self.objectivity = objectivity + self.posterity = posterity + self.postnuptial = postnuptial + self.precedentary = precedentary + self.saddling = saddling + self.subcurrent = subcurrent + self.unrecriminative = unrecriminative + } +} + +// MARK: LandlubberlyClass convenience initializers and mutators + +extension LandlubberlyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LandlubberlyClass.self, from: data) + self.init(acropoleis: me.acropoleis, aminate: me.aminate, amyraldism: me.amyraldism, bipenniform: me.bipenniform, bugre: me.bugre, calycule: me.calycule, caoutchouc: me.caoutchouc, disprover: me.disprover, fitroot: me.fitroot, fulgently: me.fulgently, kickup: me.kickup, laevoversion: me.laevoversion, moter: me.moter, objectivity: me.objectivity, posterity: me.posterity, postnuptial: me.postnuptial, precedentary: me.precedentary, saddling: me.saddling, subcurrent: me.subcurrent, unrecriminative: me.unrecriminative) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acropoleis: JSONNull?? = nil, + aminate: JSONNull?? = nil, + amyraldism: JSONNull?? = nil, + bipenniform: JSONNull?? = nil, + bugre: JSONNull?? = nil, + calycule: JSONNull?? = nil, + caoutchouc: JSONNull?? = nil, + disprover: JSONNull?? = nil, + fitroot: JSONNull?? = nil, + fulgently: JSONNull?? = nil, + kickup: JSONNull?? = nil, + laevoversion: JSONNull?? = nil, + moter: JSONNull?? = nil, + objectivity: JSONNull?? = nil, + posterity: JSONNull?? = nil, + postnuptial: JSONNull?? = nil, + precedentary: JSONNull?? = nil, + saddling: JSONNull?? = nil, + subcurrent: JSONNull?? = nil, + unrecriminative: JSONNull?? = nil + ) -> LandlubberlyClass { + return LandlubberlyClass( + acropoleis: acropoleis ?? self.acropoleis, + aminate: aminate ?? self.aminate, + amyraldism: amyraldism ?? self.amyraldism, + bipenniform: bipenniform ?? self.bipenniform, + bugre: bugre ?? self.bugre, + calycule: calycule ?? self.calycule, + caoutchouc: caoutchouc ?? self.caoutchouc, + disprover: disprover ?? self.disprover, + fitroot: fitroot ?? self.fitroot, + fulgently: fulgently ?? self.fulgently, + kickup: kickup ?? self.kickup, + laevoversion: laevoversion ?? self.laevoversion, + moter: moter ?? self.moter, + objectivity: objectivity ?? self.objectivity, + posterity: posterity ?? self.posterity, + postnuptial: postnuptial ?? self.postnuptial, + precedentary: precedentary ?? self.precedentary, + saddling: saddling ?? self.saddling, + subcurrent: subcurrent ?? self.subcurrent, + unrecriminative: unrecriminative ?? self.unrecriminative + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Listener: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum LupusElement: Codable, Sendable { + case integer(Int) + case lupusClass(LupusClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LupusClass.self) { + self = .lupusClass(x) + return + } + throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .lupusClass(let x): + try container.encode(x) + } + } +} + +// MARK: - LupusClass +final class LupusClass: Codable, Sendable { + let catharticalness: Double? + let chirotherium: Int? + let chlorioninae: Int? + let corvinae: Int? + let crassina: Int? + let disdiapason: String? + let exiguity: Int? + let farcist: Int? + let holographical: Int? + let homocerc: Bool? + let ichthyophagan: Int? + let implacable: Int? + let nonbookish: JSONNull? + let outshiner: Int? + let overweather: Int? + let protonegroid: Int? + let shallowish: Int? + let snoke: Int? + let snout: Int? + let surveillance: Int? + let threshingtime: Int? + let thysanocarpus: Int? + let unsignificantly: Int? + let unsnap: Int? + let vendible: Int? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorioninae = "Chlorioninae" + case corvinae = "Corvinae" + case crassina = "Crassina" + case disdiapason = "disdiapason" + case exiguity = "exiguity" + case farcist = "farcist" + case holographical = "holographical" + case homocerc = "homocerc" + case ichthyophagan = "ichthyophagan" + case implacable = "implacable" + case nonbookish = "nonbookish" + case outshiner = "outshiner" + case overweather = "overweather" + case protonegroid = "protonegroid" + case shallowish = "shallowish" + case snoke = "snoke" + case snout = "snout" + case surveillance = "surveillance" + case threshingtime = "threshingtime" + case thysanocarpus = "Thysanocarpus" + case unsignificantly = "unsignificantly" + case unsnap = "unsnap" + case vendible = "vendible" + } + + init(catharticalness: Double?, chirotherium: Int?, chlorioninae: Int?, corvinae: Int?, crassina: Int?, disdiapason: String?, exiguity: Int?, farcist: Int?, holographical: Int?, homocerc: Bool?, ichthyophagan: Int?, implacable: Int?, nonbookish: JSONNull?, outshiner: Int?, overweather: Int?, protonegroid: Int?, shallowish: Int?, snoke: Int?, snout: Int?, surveillance: Int?, threshingtime: Int?, thysanocarpus: Int?, unsignificantly: Int?, unsnap: Int?, vendible: Int?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chlorioninae = chlorioninae + self.corvinae = corvinae + self.crassina = crassina + self.disdiapason = disdiapason + self.exiguity = exiguity + self.farcist = farcist + self.holographical = holographical + self.homocerc = homocerc + self.ichthyophagan = ichthyophagan + self.implacable = implacable + self.nonbookish = nonbookish + self.outshiner = outshiner + self.overweather = overweather + self.protonegroid = protonegroid + self.shallowish = shallowish + self.snoke = snoke + self.snout = snout + self.surveillance = surveillance + self.threshingtime = threshingtime + self.thysanocarpus = thysanocarpus + self.unsignificantly = unsignificantly + self.unsnap = unsnap + self.vendible = vendible + } +} + +// MARK: LupusClass convenience initializers and mutators + +extension LupusClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LupusClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, chlorioninae: me.chlorioninae, corvinae: me.corvinae, crassina: me.crassina, disdiapason: me.disdiapason, exiguity: me.exiguity, farcist: me.farcist, holographical: me.holographical, homocerc: me.homocerc, ichthyophagan: me.ichthyophagan, implacable: me.implacable, nonbookish: me.nonbookish, outshiner: me.outshiner, overweather: me.overweather, protonegroid: me.protonegroid, shallowish: me.shallowish, snoke: me.snoke, snout: me.snout, surveillance: me.surveillance, threshingtime: me.threshingtime, thysanocarpus: me.thysanocarpus, unsignificantly: me.unsignificantly, unsnap: me.unsnap, vendible: me.vendible) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorioninae: Int?? = nil, + corvinae: Int?? = nil, + crassina: Int?? = nil, + disdiapason: String?? = nil, + exiguity: Int?? = nil, + farcist: Int?? = nil, + holographical: Int?? = nil, + homocerc: Bool?? = nil, + ichthyophagan: Int?? = nil, + implacable: Int?? = nil, + nonbookish: JSONNull?? = nil, + outshiner: Int?? = nil, + overweather: Int?? = nil, + protonegroid: Int?? = nil, + shallowish: Int?? = nil, + snoke: Int?? = nil, + snout: Int?? = nil, + surveillance: Int?? = nil, + threshingtime: Int?? = nil, + thysanocarpus: Int?? = nil, + unsignificantly: Int?? = nil, + unsnap: Int?? = nil, + vendible: Int?? = nil + ) -> LupusClass { + return LupusClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorioninae: chlorioninae ?? self.chlorioninae, + corvinae: corvinae ?? self.corvinae, + crassina: crassina ?? self.crassina, + disdiapason: disdiapason ?? self.disdiapason, + exiguity: exiguity ?? self.exiguity, + farcist: farcist ?? self.farcist, + holographical: holographical ?? self.holographical, + homocerc: homocerc ?? self.homocerc, + ichthyophagan: ichthyophagan ?? self.ichthyophagan, + implacable: implacable ?? self.implacable, + nonbookish: nonbookish ?? self.nonbookish, + outshiner: outshiner ?? self.outshiner, + overweather: overweather ?? self.overweather, + protonegroid: protonegroid ?? self.protonegroid, + shallowish: shallowish ?? self.shallowish, + snoke: snoke ?? self.snoke, + snout: snout ?? self.snout, + surveillance: surveillance ?? self.surveillance, + threshingtime: threshingtime ?? self.threshingtime, + thysanocarpus: thysanocarpus ?? self.thysanocarpus, + unsignificantly: unsignificantly ?? self.unsignificantly, + unsnap: unsnap ?? self.unsnap, + vendible: vendible ?? self.vendible + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Maslin +final class Maslin: Codable, Sendable { + let alicant: Int? + let antiatonement: JSONNull? + let anticorrosive: Int? + let aphidozer: JSONNull? + let bakuninist: JSONNull? + let be: Int? + let catharticalness: Double? + let chirotherium: Int? + let chub: Int? + let cuprosilicon: Int? + let curtailedly: Int? + let dellenite: Int? + let dimitry: Int? + let disdiapason: String? + let edifying: JSONNull? + let ethmoiditis: Int? + let gastralgy: JSONNull? + let goatherd: Int? + let hammerdress: Int? + let hangfire: JSONNull? + let homocerc: Bool? + let lacunosity: Int? + let longiloquence: JSONNull? + let mameliere: Int? + let motherless: JSONNull? + let nonbookish: JSONNull? + let noncorrodible: JSONNull? + let nonsensicality: JSONNull? + let oafishly: Int? + let pfund: JSONNull? + let preadvisory: JSONNull? + let retroflexed: JSONNull? + let saccharulmic: Int? + let scowlful: Int? + let secluded: JSONNull? + let slackage: JSONNull? + let sphaeridial: Int? + let spondulics: JSONNull? + let subsecive: Int? + let swellmobsman: JSONNull? + let trachyglossate: Int? + let trialogue: JSONNull? + let unassuaged: Int? + let ungross: JSONNull? + let unjudiciously: JSONNull? + + enum CodingKeys: String, CodingKey { + case alicant = "Alicant" + case antiatonement = "antiatonement" + case anticorrosive = "anticorrosive" + case aphidozer = "aphidozer" + case bakuninist = "Bakuninist" + case be = "be" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chub = "chub" + case cuprosilicon = "cuprosilicon" + case curtailedly = "curtailedly" + case dellenite = "dellenite" + case dimitry = "Dimitry" + case disdiapason = "disdiapason" + case edifying = "edifying" + case ethmoiditis = "ethmoiditis" + case gastralgy = "gastralgy" + case goatherd = "goatherd" + case hammerdress = "hammerdress" + case hangfire = "hangfire" + case homocerc = "homocerc" + case lacunosity = "lacunosity" + case longiloquence = "longiloquence" + case mameliere = "mameliere" + case motherless = "motherless" + case nonbookish = "nonbookish" + case noncorrodible = "noncorrodible" + case nonsensicality = "nonsensicality" + case oafishly = "oafishly" + case pfund = "pfund" + case preadvisory = "preadvisory" + case retroflexed = "retroflexed" + case saccharulmic = "saccharulmic" + case scowlful = "scowlful" + case secluded = "secluded" + case slackage = "slackage" + case sphaeridial = "sphaeridial" + case spondulics = "spondulics" + case subsecive = "subsecive" + case swellmobsman = "swellmobsman" + case trachyglossate = "trachyglossate" + case trialogue = "trialogue" + case unassuaged = "unassuaged" + case ungross = "ungross" + case unjudiciously = "unjudiciously" + } + + init(alicant: Int?, antiatonement: JSONNull?, anticorrosive: Int?, aphidozer: JSONNull?, bakuninist: JSONNull?, be: Int?, catharticalness: Double?, chirotherium: Int?, chub: Int?, cuprosilicon: Int?, curtailedly: Int?, dellenite: Int?, dimitry: Int?, disdiapason: String?, edifying: JSONNull?, ethmoiditis: Int?, gastralgy: JSONNull?, goatherd: Int?, hammerdress: Int?, hangfire: JSONNull?, homocerc: Bool?, lacunosity: Int?, longiloquence: JSONNull?, mameliere: Int?, motherless: JSONNull?, nonbookish: JSONNull?, noncorrodible: JSONNull?, nonsensicality: JSONNull?, oafishly: Int?, pfund: JSONNull?, preadvisory: JSONNull?, retroflexed: JSONNull?, saccharulmic: Int?, scowlful: Int?, secluded: JSONNull?, slackage: JSONNull?, sphaeridial: Int?, spondulics: JSONNull?, subsecive: Int?, swellmobsman: JSONNull?, trachyglossate: Int?, trialogue: JSONNull?, unassuaged: Int?, ungross: JSONNull?, unjudiciously: JSONNull?) { + self.alicant = alicant + self.antiatonement = antiatonement + self.anticorrosive = anticorrosive + self.aphidozer = aphidozer + self.bakuninist = bakuninist + self.be = be + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chub = chub + self.cuprosilicon = cuprosilicon + self.curtailedly = curtailedly + self.dellenite = dellenite + self.dimitry = dimitry + self.disdiapason = disdiapason + self.edifying = edifying + self.ethmoiditis = ethmoiditis + self.gastralgy = gastralgy + self.goatherd = goatherd + self.hammerdress = hammerdress + self.hangfire = hangfire + self.homocerc = homocerc + self.lacunosity = lacunosity + self.longiloquence = longiloquence + self.mameliere = mameliere + self.motherless = motherless + self.nonbookish = nonbookish + self.noncorrodible = noncorrodible + self.nonsensicality = nonsensicality + self.oafishly = oafishly + self.pfund = pfund + self.preadvisory = preadvisory + self.retroflexed = retroflexed + self.saccharulmic = saccharulmic + self.scowlful = scowlful + self.secluded = secluded + self.slackage = slackage + self.sphaeridial = sphaeridial + self.spondulics = spondulics + self.subsecive = subsecive + self.swellmobsman = swellmobsman + self.trachyglossate = trachyglossate + self.trialogue = trialogue + self.unassuaged = unassuaged + self.ungross = ungross + self.unjudiciously = unjudiciously + } +} + +// MARK: Maslin convenience initializers and mutators + +extension Maslin { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Maslin.self, from: data) + self.init(alicant: me.alicant, antiatonement: me.antiatonement, anticorrosive: me.anticorrosive, aphidozer: me.aphidozer, bakuninist: me.bakuninist, be: me.be, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chub: me.chub, cuprosilicon: me.cuprosilicon, curtailedly: me.curtailedly, dellenite: me.dellenite, dimitry: me.dimitry, disdiapason: me.disdiapason, edifying: me.edifying, ethmoiditis: me.ethmoiditis, gastralgy: me.gastralgy, goatherd: me.goatherd, hammerdress: me.hammerdress, hangfire: me.hangfire, homocerc: me.homocerc, lacunosity: me.lacunosity, longiloquence: me.longiloquence, mameliere: me.mameliere, motherless: me.motherless, nonbookish: me.nonbookish, noncorrodible: me.noncorrodible, nonsensicality: me.nonsensicality, oafishly: me.oafishly, pfund: me.pfund, preadvisory: me.preadvisory, retroflexed: me.retroflexed, saccharulmic: me.saccharulmic, scowlful: me.scowlful, secluded: me.secluded, slackage: me.slackage, sphaeridial: me.sphaeridial, spondulics: me.spondulics, subsecive: me.subsecive, swellmobsman: me.swellmobsman, trachyglossate: me.trachyglossate, trialogue: me.trialogue, unassuaged: me.unassuaged, ungross: me.ungross, unjudiciously: me.unjudiciously) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alicant: Int?? = nil, + antiatonement: JSONNull?? = nil, + anticorrosive: Int?? = nil, + aphidozer: JSONNull?? = nil, + bakuninist: JSONNull?? = nil, + be: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chub: Int?? = nil, + cuprosilicon: Int?? = nil, + curtailedly: Int?? = nil, + dellenite: Int?? = nil, + dimitry: Int?? = nil, + disdiapason: String?? = nil, + edifying: JSONNull?? = nil, + ethmoiditis: Int?? = nil, + gastralgy: JSONNull?? = nil, + goatherd: Int?? = nil, + hammerdress: Int?? = nil, + hangfire: JSONNull?? = nil, + homocerc: Bool?? = nil, + lacunosity: Int?? = nil, + longiloquence: JSONNull?? = nil, + mameliere: Int?? = nil, + motherless: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + noncorrodible: JSONNull?? = nil, + nonsensicality: JSONNull?? = nil, + oafishly: Int?? = nil, + pfund: JSONNull?? = nil, + preadvisory: JSONNull?? = nil, + retroflexed: JSONNull?? = nil, + saccharulmic: Int?? = nil, + scowlful: Int?? = nil, + secluded: JSONNull?? = nil, + slackage: JSONNull?? = nil, + sphaeridial: Int?? = nil, + spondulics: JSONNull?? = nil, + subsecive: Int?? = nil, + swellmobsman: JSONNull?? = nil, + trachyglossate: Int?? = nil, + trialogue: JSONNull?? = nil, + unassuaged: Int?? = nil, + ungross: JSONNull?? = nil, + unjudiciously: JSONNull?? = nil + ) -> Maslin { + return Maslin( + alicant: alicant ?? self.alicant, + antiatonement: antiatonement ?? self.antiatonement, + anticorrosive: anticorrosive ?? self.anticorrosive, + aphidozer: aphidozer ?? self.aphidozer, + bakuninist: bakuninist ?? self.bakuninist, + be: be ?? self.be, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chub: chub ?? self.chub, + cuprosilicon: cuprosilicon ?? self.cuprosilicon, + curtailedly: curtailedly ?? self.curtailedly, + dellenite: dellenite ?? self.dellenite, + dimitry: dimitry ?? self.dimitry, + disdiapason: disdiapason ?? self.disdiapason, + edifying: edifying ?? self.edifying, + ethmoiditis: ethmoiditis ?? self.ethmoiditis, + gastralgy: gastralgy ?? self.gastralgy, + goatherd: goatherd ?? self.goatherd, + hammerdress: hammerdress ?? self.hammerdress, + hangfire: hangfire ?? self.hangfire, + homocerc: homocerc ?? self.homocerc, + lacunosity: lacunosity ?? self.lacunosity, + longiloquence: longiloquence ?? self.longiloquence, + mameliere: mameliere ?? self.mameliere, + motherless: motherless ?? self.motherless, + nonbookish: nonbookish ?? self.nonbookish, + noncorrodible: noncorrodible ?? self.noncorrodible, + nonsensicality: nonsensicality ?? self.nonsensicality, + oafishly: oafishly ?? self.oafishly, + pfund: pfund ?? self.pfund, + preadvisory: preadvisory ?? self.preadvisory, + retroflexed: retroflexed ?? self.retroflexed, + saccharulmic: saccharulmic ?? self.saccharulmic, + scowlful: scowlful ?? self.scowlful, + secluded: secluded ?? self.secluded, + slackage: slackage ?? self.slackage, + sphaeridial: sphaeridial ?? self.sphaeridial, + spondulics: spondulics ?? self.spondulics, + subsecive: subsecive ?? self.subsecive, + swellmobsman: swellmobsman ?? self.swellmobsman, + trachyglossate: trachyglossate ?? self.trachyglossate, + trialogue: trialogue ?? self.trialogue, + unassuaged: unassuaged ?? self.unassuaged, + ungross: ungross ?? self.ungross, + unjudiciously: unjudiciously ?? self.unjudiciously + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum MonaziteElement: Codable, Sendable { + case double(Double) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - MonaziteClass +final class MonaziteClass: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: MonaziteClass convenience initializers and mutators + +extension MonaziteClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(MonaziteClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> MonaziteClass { + return MonaziteClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Monoliteral: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum MonotheisticallyElement: Codable, Sendable { + case monotheisticallyClass(MonotheisticallyClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonotheisticallyClass.self) { + self = .monotheisticallyClass(x) + return + } + throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monotheisticallyClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - MonotheisticallyClass +final class MonotheisticallyClass: Codable, Sendable { + let blaspheme: JSONNull? + let catharticalness: Double? + let celiosalpingectomy: JSONNull? + let chirotherium: Int? + let consummativeness: JSONNull? + let disdiapason: String? + let egestive: JSONNull? + let enchylema: JSONNull? + let gasconade: JSONNull? + let holidayer: JSONNull? + let homocerc: Bool? + let intuitionalism: JSONNull? + let lophiostomate: JSONNull? + let nonbookish: JSONNull? + let nonvolition: JSONNull? + let palatableness: JSONNull? + let pimpery: JSONNull? + let previolation: JSONNull? + let reconveyance: JSONNull? + let registership: JSONNull? + let rhyacolite: JSONNull? + let smithereens: JSONNull? + let superedification: JSONNull? + let trust: JSONNull? + let whitestone: JSONNull? + + enum CodingKeys: String, CodingKey { + case blaspheme = "blaspheme" + case catharticalness = "catharticalness" + case celiosalpingectomy = "celiosalpingectomy" + case chirotherium = "Chirotherium" + case consummativeness = "consummativeness" + case disdiapason = "disdiapason" + case egestive = "egestive" + case enchylema = "enchylema" + case gasconade = "gasconade" + case holidayer = "holidayer" + case homocerc = "homocerc" + case intuitionalism = "intuitionalism" + case lophiostomate = "lophiostomate" + case nonbookish = "nonbookish" + case nonvolition = "nonvolition" + case palatableness = "palatableness" + case pimpery = "pimpery" + case previolation = "previolation" + case reconveyance = "reconveyance" + case registership = "registership" + case rhyacolite = "rhyacolite" + case smithereens = "smithereens" + case superedification = "superedification" + case trust = "trust" + case whitestone = "whitestone" + } + + init(blaspheme: JSONNull?, catharticalness: Double?, celiosalpingectomy: JSONNull?, chirotherium: Int?, consummativeness: JSONNull?, disdiapason: String?, egestive: JSONNull?, enchylema: JSONNull?, gasconade: JSONNull?, holidayer: JSONNull?, homocerc: Bool?, intuitionalism: JSONNull?, lophiostomate: JSONNull?, nonbookish: JSONNull?, nonvolition: JSONNull?, palatableness: JSONNull?, pimpery: JSONNull?, previolation: JSONNull?, reconveyance: JSONNull?, registership: JSONNull?, rhyacolite: JSONNull?, smithereens: JSONNull?, superedification: JSONNull?, trust: JSONNull?, whitestone: JSONNull?) { + self.blaspheme = blaspheme + self.catharticalness = catharticalness + self.celiosalpingectomy = celiosalpingectomy + self.chirotherium = chirotherium + self.consummativeness = consummativeness + self.disdiapason = disdiapason + self.egestive = egestive + self.enchylema = enchylema + self.gasconade = gasconade + self.holidayer = holidayer + self.homocerc = homocerc + self.intuitionalism = intuitionalism + self.lophiostomate = lophiostomate + self.nonbookish = nonbookish + self.nonvolition = nonvolition + self.palatableness = palatableness + self.pimpery = pimpery + self.previolation = previolation + self.reconveyance = reconveyance + self.registership = registership + self.rhyacolite = rhyacolite + self.smithereens = smithereens + self.superedification = superedification + self.trust = trust + self.whitestone = whitestone + } +} + +// MARK: MonotheisticallyClass convenience initializers and mutators + +extension MonotheisticallyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data) + self.init(blaspheme: me.blaspheme, catharticalness: me.catharticalness, celiosalpingectomy: me.celiosalpingectomy, chirotherium: me.chirotherium, consummativeness: me.consummativeness, disdiapason: me.disdiapason, egestive: me.egestive, enchylema: me.enchylema, gasconade: me.gasconade, holidayer: me.holidayer, homocerc: me.homocerc, intuitionalism: me.intuitionalism, lophiostomate: me.lophiostomate, nonbookish: me.nonbookish, nonvolition: me.nonvolition, palatableness: me.palatableness, pimpery: me.pimpery, previolation: me.previolation, reconveyance: me.reconveyance, registership: me.registership, rhyacolite: me.rhyacolite, smithereens: me.smithereens, superedification: me.superedification, trust: me.trust, whitestone: me.whitestone) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + blaspheme: JSONNull?? = nil, + catharticalness: Double?? = nil, + celiosalpingectomy: JSONNull?? = nil, + chirotherium: Int?? = nil, + consummativeness: JSONNull?? = nil, + disdiapason: String?? = nil, + egestive: JSONNull?? = nil, + enchylema: JSONNull?? = nil, + gasconade: JSONNull?? = nil, + holidayer: JSONNull?? = nil, + homocerc: Bool?? = nil, + intuitionalism: JSONNull?? = nil, + lophiostomate: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nonvolition: JSONNull?? = nil, + palatableness: JSONNull?? = nil, + pimpery: JSONNull?? = nil, + previolation: JSONNull?? = nil, + reconveyance: JSONNull?? = nil, + registership: JSONNull?? = nil, + rhyacolite: JSONNull?? = nil, + smithereens: JSONNull?? = nil, + superedification: JSONNull?? = nil, + trust: JSONNull?? = nil, + whitestone: JSONNull?? = nil + ) -> MonotheisticallyClass { + return MonotheisticallyClass( + blaspheme: blaspheme ?? self.blaspheme, + catharticalness: catharticalness ?? self.catharticalness, + celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy, + chirotherium: chirotherium ?? self.chirotherium, + consummativeness: consummativeness ?? self.consummativeness, + disdiapason: disdiapason ?? self.disdiapason, + egestive: egestive ?? self.egestive, + enchylema: enchylema ?? self.enchylema, + gasconade: gasconade ?? self.gasconade, + holidayer: holidayer ?? self.holidayer, + homocerc: homocerc ?? self.homocerc, + intuitionalism: intuitionalism ?? self.intuitionalism, + lophiostomate: lophiostomate ?? self.lophiostomate, + nonbookish: nonbookish ?? self.nonbookish, + nonvolition: nonvolition ?? self.nonvolition, + palatableness: palatableness ?? self.palatableness, + pimpery: pimpery ?? self.pimpery, + previolation: previolation ?? self.previolation, + reconveyance: reconveyance ?? self.reconveyance, + registership: registership ?? self.registership, + rhyacolite: rhyacolite ?? self.rhyacolite, + smithereens: smithereens ?? self.smithereens, + superedification: superedification ?? self.superedification, + trust: trust ?? self.trust, + whitestone: whitestone ?? self.whitestone + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Montage: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Moralness: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Mulishly: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Myoscope: Codable, Sendable { + case bool(Bool) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Neuromastic: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - Noncontributing +final class Noncontributing: Codable, Sendable { + let estevin: String + let jolterhead: Double + let sauternes: Int + let sparsely: Bool + let unrequested: JSONNull? + + enum CodingKeys: String, CodingKey { + case estevin = "estevin" + case jolterhead = "jolterhead" + case sauternes = "sauternes" + case sparsely = "sparsely" + case unrequested = "unrequested" + } + + init(estevin: String, jolterhead: Double, sauternes: Int, sparsely: Bool, unrequested: JSONNull?) { + self.estevin = estevin + self.jolterhead = jolterhead + self.sauternes = sauternes + self.sparsely = sparsely + self.unrequested = unrequested + } +} + +// MARK: Noncontributing convenience initializers and mutators + +extension Noncontributing { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Noncontributing.self, from: data) + self.init(estevin: me.estevin, jolterhead: me.jolterhead, sauternes: me.sauternes, sparsely: me.sparsely, unrequested: me.unrequested) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + estevin: String? = nil, + jolterhead: Double? = nil, + sauternes: Int? = nil, + sparsely: Bool? = nil, + unrequested: JSONNull?? = nil + ) -> Noncontributing { + return Noncontributing( + estevin: estevin ?? self.estevin, + jolterhead: jolterhead ?? self.jolterhead, + sauternes: sauternes ?? self.sauternes, + sparsely: sparsely ?? self.sparsely, + unrequested: unrequested ?? self.unrequested + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Nonnervous: Codable, Sendable { + case bool(Bool) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Nonvaluation: Codable, Sendable { + case bool(Bool) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum OccupationalistElement: Codable, Sendable { + case nullArray([JSONNull?]) + case occupationalistClass(OccupationalistClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(OccupationalistClass.self) { + self = .occupationalistClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .occupationalistClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - OccupationalistClass +final class OccupationalistClass: Codable, Sendable { + let beholdable: JSONNull? + let brotuliform: JSONNull? + let chimakum: JSONNull? + let doodler: JSONNull? + let emulsin: JSONNull? + let fin: JSONNull? + let flourishing: JSONNull? + let flueless: JSONNull? + let furtively: JSONNull? + let gritter: JSONNull? + let interwish: JSONNull? + let monoxylic: JSONNull? + let myristic: JSONNull? + let nightwear: JSONNull? + let peruser: JSONNull? + let theoastrological: JSONNull? + let thumby: JSONNull? + let tingitid: JSONNull? + let trailless: JSONNull? + let unpocketed: JSONNull? + + enum CodingKeys: String, CodingKey { + case beholdable = "beholdable" + case brotuliform = "brotuliform" + case chimakum = "Chimakum" + case doodler = "doodler" + case emulsin = "emulsin" + case fin = "Fin" + case flourishing = "flourishing" + case flueless = "flueless" + case furtively = "furtively" + case gritter = "gritter" + case interwish = "interwish" + case monoxylic = "monoxylic" + case myristic = "myristic" + case nightwear = "nightwear" + case peruser = "peruser" + case theoastrological = "theoastrological" + case thumby = "thumby" + case tingitid = "tingitid" + case trailless = "trailless" + case unpocketed = "unpocketed" + } + + init(beholdable: JSONNull?, brotuliform: JSONNull?, chimakum: JSONNull?, doodler: JSONNull?, emulsin: JSONNull?, fin: JSONNull?, flourishing: JSONNull?, flueless: JSONNull?, furtively: JSONNull?, gritter: JSONNull?, interwish: JSONNull?, monoxylic: JSONNull?, myristic: JSONNull?, nightwear: JSONNull?, peruser: JSONNull?, theoastrological: JSONNull?, thumby: JSONNull?, tingitid: JSONNull?, trailless: JSONNull?, unpocketed: JSONNull?) { + self.beholdable = beholdable + self.brotuliform = brotuliform + self.chimakum = chimakum + self.doodler = doodler + self.emulsin = emulsin + self.fin = fin + self.flourishing = flourishing + self.flueless = flueless + self.furtively = furtively + self.gritter = gritter + self.interwish = interwish + self.monoxylic = monoxylic + self.myristic = myristic + self.nightwear = nightwear + self.peruser = peruser + self.theoastrological = theoastrological + self.thumby = thumby + self.tingitid = tingitid + self.trailless = trailless + self.unpocketed = unpocketed + } +} + +// MARK: OccupationalistClass convenience initializers and mutators + +extension OccupationalistClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OccupationalistClass.self, from: data) + self.init(beholdable: me.beholdable, brotuliform: me.brotuliform, chimakum: me.chimakum, doodler: me.doodler, emulsin: me.emulsin, fin: me.fin, flourishing: me.flourishing, flueless: me.flueless, furtively: me.furtively, gritter: me.gritter, interwish: me.interwish, monoxylic: me.monoxylic, myristic: me.myristic, nightwear: me.nightwear, peruser: me.peruser, theoastrological: me.theoastrological, thumby: me.thumby, tingitid: me.tingitid, trailless: me.trailless, unpocketed: me.unpocketed) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + beholdable: JSONNull?? = nil, + brotuliform: JSONNull?? = nil, + chimakum: JSONNull?? = nil, + doodler: JSONNull?? = nil, + emulsin: JSONNull?? = nil, + fin: JSONNull?? = nil, + flourishing: JSONNull?? = nil, + flueless: JSONNull?? = nil, + furtively: JSONNull?? = nil, + gritter: JSONNull?? = nil, + interwish: JSONNull?? = nil, + monoxylic: JSONNull?? = nil, + myristic: JSONNull?? = nil, + nightwear: JSONNull?? = nil, + peruser: JSONNull?? = nil, + theoastrological: JSONNull?? = nil, + thumby: JSONNull?? = nil, + tingitid: JSONNull?? = nil, + trailless: JSONNull?? = nil, + unpocketed: JSONNull?? = nil + ) -> OccupationalistClass { + return OccupationalistClass( + beholdable: beholdable ?? self.beholdable, + brotuliform: brotuliform ?? self.brotuliform, + chimakum: chimakum ?? self.chimakum, + doodler: doodler ?? self.doodler, + emulsin: emulsin ?? self.emulsin, + fin: fin ?? self.fin, + flourishing: flourishing ?? self.flourishing, + flueless: flueless ?? self.flueless, + furtively: furtively ?? self.furtively, + gritter: gritter ?? self.gritter, + interwish: interwish ?? self.interwish, + monoxylic: monoxylic ?? self.monoxylic, + myristic: myristic ?? self.myristic, + nightwear: nightwear ?? self.nightwear, + peruser: peruser ?? self.peruser, + theoastrological: theoastrological ?? self.theoastrological, + thumby: thumby ?? self.thumby, + tingitid: tingitid ?? self.tingitid, + trailless: trailless ?? self.trailless, + unpocketed: unpocketed ?? self.unpocketed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OutrivalElement: Codable, Sendable { + case double(Double) + case outrivalClass(OutrivalClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(OutrivalClass.self) { + self = .outrivalClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .outrivalClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - OutrivalClass +final class OutrivalClass: Codable, Sendable { + let adroitly: JSONNull? + let bridehood: JSONNull? + let castoroides: JSONNull? + let czechoslovak: JSONNull? + let diagenesis: JSONNull? + let dihexahedron: JSONNull? + let dopester: JSONNull? + let eumerism: JSONNull? + let flyness: JSONNull? + let fouler: JSONNull? + let laudanosine: JSONNull? + let lingulidae: JSONNull? + let minutary: JSONNull? + let mitra: JSONNull? + let opisthorchiasis: JSONNull? + let pensively: JSONNull? + let pubigerous: JSONNull? + let rebellious: JSONNull? + let recodify: JSONNull? + let unpaced: JSONNull? + + enum CodingKeys: String, CodingKey { + case adroitly = "adroitly" + case bridehood = "bridehood" + case castoroides = "Castoroides" + case czechoslovak = "Czechoslovak" + case diagenesis = "diagenesis" + case dihexahedron = "dihexahedron" + case dopester = "dopester" + case eumerism = "eumerism" + case flyness = "flyness" + case fouler = "fouler" + case laudanosine = "laudanosine" + case lingulidae = "Lingulidae" + case minutary = "minutary" + case mitra = "mitra" + case opisthorchiasis = "opisthorchiasis" + case pensively = "pensively" + case pubigerous = "pubigerous" + case rebellious = "rebellious" + case recodify = "recodify" + case unpaced = "unpaced" + } + + init(adroitly: JSONNull?, bridehood: JSONNull?, castoroides: JSONNull?, czechoslovak: JSONNull?, diagenesis: JSONNull?, dihexahedron: JSONNull?, dopester: JSONNull?, eumerism: JSONNull?, flyness: JSONNull?, fouler: JSONNull?, laudanosine: JSONNull?, lingulidae: JSONNull?, minutary: JSONNull?, mitra: JSONNull?, opisthorchiasis: JSONNull?, pensively: JSONNull?, pubigerous: JSONNull?, rebellious: JSONNull?, recodify: JSONNull?, unpaced: JSONNull?) { + self.adroitly = adroitly + self.bridehood = bridehood + self.castoroides = castoroides + self.czechoslovak = czechoslovak + self.diagenesis = diagenesis + self.dihexahedron = dihexahedron + self.dopester = dopester + self.eumerism = eumerism + self.flyness = flyness + self.fouler = fouler + self.laudanosine = laudanosine + self.lingulidae = lingulidae + self.minutary = minutary + self.mitra = mitra + self.opisthorchiasis = opisthorchiasis + self.pensively = pensively + self.pubigerous = pubigerous + self.rebellious = rebellious + self.recodify = recodify + self.unpaced = unpaced + } +} + +// MARK: OutrivalClass convenience initializers and mutators + +extension OutrivalClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OutrivalClass.self, from: data) + self.init(adroitly: me.adroitly, bridehood: me.bridehood, castoroides: me.castoroides, czechoslovak: me.czechoslovak, diagenesis: me.diagenesis, dihexahedron: me.dihexahedron, dopester: me.dopester, eumerism: me.eumerism, flyness: me.flyness, fouler: me.fouler, laudanosine: me.laudanosine, lingulidae: me.lingulidae, minutary: me.minutary, mitra: me.mitra, opisthorchiasis: me.opisthorchiasis, pensively: me.pensively, pubigerous: me.pubigerous, rebellious: me.rebellious, recodify: me.recodify, unpaced: me.unpaced) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adroitly: JSONNull?? = nil, + bridehood: JSONNull?? = nil, + castoroides: JSONNull?? = nil, + czechoslovak: JSONNull?? = nil, + diagenesis: JSONNull?? = nil, + dihexahedron: JSONNull?? = nil, + dopester: JSONNull?? = nil, + eumerism: JSONNull?? = nil, + flyness: JSONNull?? = nil, + fouler: JSONNull?? = nil, + laudanosine: JSONNull?? = nil, + lingulidae: JSONNull?? = nil, + minutary: JSONNull?? = nil, + mitra: JSONNull?? = nil, + opisthorchiasis: JSONNull?? = nil, + pensively: JSONNull?? = nil, + pubigerous: JSONNull?? = nil, + rebellious: JSONNull?? = nil, + recodify: JSONNull?? = nil, + unpaced: JSONNull?? = nil + ) -> OutrivalClass { + return OutrivalClass( + adroitly: adroitly ?? self.adroitly, + bridehood: bridehood ?? self.bridehood, + castoroides: castoroides ?? self.castoroides, + czechoslovak: czechoslovak ?? self.czechoslovak, + diagenesis: diagenesis ?? self.diagenesis, + dihexahedron: dihexahedron ?? self.dihexahedron, + dopester: dopester ?? self.dopester, + eumerism: eumerism ?? self.eumerism, + flyness: flyness ?? self.flyness, + fouler: fouler ?? self.fouler, + laudanosine: laudanosine ?? self.laudanosine, + lingulidae: lingulidae ?? self.lingulidae, + minutary: minutary ?? self.minutary, + mitra: mitra ?? self.mitra, + opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis, + pensively: pensively ?? self.pensively, + pubigerous: pubigerous ?? self.pubigerous, + rebellious: rebellious ?? self.rebellious, + recodify: recodify ?? self.recodify, + unpaced: unpaced ?? self.unpaced + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Paleographically: Codable, Sendable { + case double(Double) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Pamphletwise: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Pediatric: Codable, Sendable { + case bool(Bool) + case double(Double) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PiaculumElement: Codable, Sendable { + case double(Double) + case piaculumClass(PiaculumClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PiaculumClass.self) { + self = .piaculumClass(x) + return + } + throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .piaculumClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PiaculumClass +final class PiaculumClass: Codable, Sendable { + let alada: Int? + let amphistomous: Int? + let boysenberry: Int? + let catharticalness: Double? + let chirotherium: Int? + let decardinalize: Int? + let discouragement: Int? + let disdiapason: String? + let doitrified: Int? + let hexaspermous: Int? + let homocerc: Bool? + let insinking: Int? + let loathfulness: Int? + let miasmatical: Int? + let neurofibril: Int? + let nonbookish: JSONNull? + let phonendoscope: Int? + let pilferment: Int? + let predismissory: Int? + let preinscription: Int? + let quotative: Int? + let sienna: Int? + let thorax: Int? + let yachting: Int? + let zipper: Int? + + enum CodingKeys: String, CodingKey { + case alada = "alada" + case amphistomous = "amphistomous" + case boysenberry = "boysenberry" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case decardinalize = "decardinalize" + case discouragement = "discouragement" + case disdiapason = "disdiapason" + case doitrified = "doitrified" + case hexaspermous = "hexaspermous" + case homocerc = "homocerc" + case insinking = "insinking" + case loathfulness = "loathfulness" + case miasmatical = "miasmatical" + case neurofibril = "neurofibril" + case nonbookish = "nonbookish" + case phonendoscope = "phonendoscope" + case pilferment = "pilferment" + case predismissory = "predismissory" + case preinscription = "preinscription" + case quotative = "quotative" + case sienna = "sienna" + case thorax = "thorax" + case yachting = "yachting" + case zipper = "Zipper" + } + + init(alada: Int?, amphistomous: Int?, boysenberry: Int?, catharticalness: Double?, chirotherium: Int?, decardinalize: Int?, discouragement: Int?, disdiapason: String?, doitrified: Int?, hexaspermous: Int?, homocerc: Bool?, insinking: Int?, loathfulness: Int?, miasmatical: Int?, neurofibril: Int?, nonbookish: JSONNull?, phonendoscope: Int?, pilferment: Int?, predismissory: Int?, preinscription: Int?, quotative: Int?, sienna: Int?, thorax: Int?, yachting: Int?, zipper: Int?) { + self.alada = alada + self.amphistomous = amphistomous + self.boysenberry = boysenberry + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.decardinalize = decardinalize + self.discouragement = discouragement + self.disdiapason = disdiapason + self.doitrified = doitrified + self.hexaspermous = hexaspermous + self.homocerc = homocerc + self.insinking = insinking + self.loathfulness = loathfulness + self.miasmatical = miasmatical + self.neurofibril = neurofibril + self.nonbookish = nonbookish + self.phonendoscope = phonendoscope + self.pilferment = pilferment + self.predismissory = predismissory + self.preinscription = preinscription + self.quotative = quotative + self.sienna = sienna + self.thorax = thorax + self.yachting = yachting + self.zipper = zipper + } +} + +// MARK: PiaculumClass convenience initializers and mutators + +extension PiaculumClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PiaculumClass.self, from: data) + self.init(alada: me.alada, amphistomous: me.amphistomous, boysenberry: me.boysenberry, catharticalness: me.catharticalness, chirotherium: me.chirotherium, decardinalize: me.decardinalize, discouragement: me.discouragement, disdiapason: me.disdiapason, doitrified: me.doitrified, hexaspermous: me.hexaspermous, homocerc: me.homocerc, insinking: me.insinking, loathfulness: me.loathfulness, miasmatical: me.miasmatical, neurofibril: me.neurofibril, nonbookish: me.nonbookish, phonendoscope: me.phonendoscope, pilferment: me.pilferment, predismissory: me.predismissory, preinscription: me.preinscription, quotative: me.quotative, sienna: me.sienna, thorax: me.thorax, yachting: me.yachting, zipper: me.zipper) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alada: Int?? = nil, + amphistomous: Int?? = nil, + boysenberry: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + decardinalize: Int?? = nil, + discouragement: Int?? = nil, + disdiapason: String?? = nil, + doitrified: Int?? = nil, + hexaspermous: Int?? = nil, + homocerc: Bool?? = nil, + insinking: Int?? = nil, + loathfulness: Int?? = nil, + miasmatical: Int?? = nil, + neurofibril: Int?? = nil, + nonbookish: JSONNull?? = nil, + phonendoscope: Int?? = nil, + pilferment: Int?? = nil, + predismissory: Int?? = nil, + preinscription: Int?? = nil, + quotative: Int?? = nil, + sienna: Int?? = nil, + thorax: Int?? = nil, + yachting: Int?? = nil, + zipper: Int?? = nil + ) -> PiaculumClass { + return PiaculumClass( + alada: alada ?? self.alada, + amphistomous: amphistomous ?? self.amphistomous, + boysenberry: boysenberry ?? self.boysenberry, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + decardinalize: decardinalize ?? self.decardinalize, + discouragement: discouragement ?? self.discouragement, + disdiapason: disdiapason ?? self.disdiapason, + doitrified: doitrified ?? self.doitrified, + hexaspermous: hexaspermous ?? self.hexaspermous, + homocerc: homocerc ?? self.homocerc, + insinking: insinking ?? self.insinking, + loathfulness: loathfulness ?? self.loathfulness, + miasmatical: miasmatical ?? self.miasmatical, + neurofibril: neurofibril ?? self.neurofibril, + nonbookish: nonbookish ?? self.nonbookish, + phonendoscope: phonendoscope ?? self.phonendoscope, + pilferment: pilferment ?? self.pilferment, + predismissory: predismissory ?? self.predismissory, + preinscription: preinscription ?? self.preinscription, + quotative: quotative ?? self.quotative, + sienna: sienna ?? self.sienna, + thorax: thorax ?? self.thorax, + yachting: yachting ?? self.yachting, + zipper: zipper ?? self.zipper + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Piccadilly: Codable, Sendable { + case double(Double) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Piffler: Codable, Sendable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Pithful: Codable, Sendable { + case bool(Bool) + case integer(Int) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Placuntiti: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Plectopterous: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Pneumocele +final class Pneumocele: Codable, Sendable { + let carbonarism: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let cineolic: JSONNull? + let cobbly: JSONNull? + let conchyliferous: JSONNull? + let congregation: JSONNull? + let disdiapason: String? + let enterotomy: JSONNull? + let entophytal: JSONNull? + let fewtrils: JSONNull? + let herem: JSONNull? + let homocerc: Bool? + let koniga: JSONNull? + let meticulosity: JSONNull? + let micky: JSONNull? + let mismarriage: JSONNull? + let neurotrophic: JSONNull? + let nonbookish: JSONNull? + let persuasively: JSONNull? + let replaceable: JSONNull? + let silex: JSONNull? + let taillight: JSONNull? + let unjealous: JSONNull? + let visitorial: JSONNull? + + enum CodingKeys: String, CodingKey { + case carbonarism = "Carbonarism" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cineolic = "cineolic" + case cobbly = "cobbly" + case conchyliferous = "conchyliferous" + case congregation = "congregation" + case disdiapason = "disdiapason" + case enterotomy = "enterotomy" + case entophytal = "entophytal" + case fewtrils = "fewtrils" + case herem = "herem" + case homocerc = "homocerc" + case koniga = "Koniga" + case meticulosity = "meticulosity" + case micky = "Micky" + case mismarriage = "mismarriage" + case neurotrophic = "neurotrophic" + case nonbookish = "nonbookish" + case persuasively = "persuasively" + case replaceable = "replaceable" + case silex = "silex" + case taillight = "taillight" + case unjealous = "unjealous" + case visitorial = "visitorial" + } + + init(carbonarism: JSONNull?, catharticalness: Double?, chirotherium: Int?, cineolic: JSONNull?, cobbly: JSONNull?, conchyliferous: JSONNull?, congregation: JSONNull?, disdiapason: String?, enterotomy: JSONNull?, entophytal: JSONNull?, fewtrils: JSONNull?, herem: JSONNull?, homocerc: Bool?, koniga: JSONNull?, meticulosity: JSONNull?, micky: JSONNull?, mismarriage: JSONNull?, neurotrophic: JSONNull?, nonbookish: JSONNull?, persuasively: JSONNull?, replaceable: JSONNull?, silex: JSONNull?, taillight: JSONNull?, unjealous: JSONNull?, visitorial: JSONNull?) { + self.carbonarism = carbonarism + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.cineolic = cineolic + self.cobbly = cobbly + self.conchyliferous = conchyliferous + self.congregation = congregation + self.disdiapason = disdiapason + self.enterotomy = enterotomy + self.entophytal = entophytal + self.fewtrils = fewtrils + self.herem = herem + self.homocerc = homocerc + self.koniga = koniga + self.meticulosity = meticulosity + self.micky = micky + self.mismarriage = mismarriage + self.neurotrophic = neurotrophic + self.nonbookish = nonbookish + self.persuasively = persuasively + self.replaceable = replaceable + self.silex = silex + self.taillight = taillight + self.unjealous = unjealous + self.visitorial = visitorial + } +} + +// MARK: Pneumocele convenience initializers and mutators + +extension Pneumocele { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Pneumocele.self, from: data) + self.init(carbonarism: me.carbonarism, catharticalness: me.catharticalness, chirotherium: me.chirotherium, cineolic: me.cineolic, cobbly: me.cobbly, conchyliferous: me.conchyliferous, congregation: me.congregation, disdiapason: me.disdiapason, enterotomy: me.enterotomy, entophytal: me.entophytal, fewtrils: me.fewtrils, herem: me.herem, homocerc: me.homocerc, koniga: me.koniga, meticulosity: me.meticulosity, micky: me.micky, mismarriage: me.mismarriage, neurotrophic: me.neurotrophic, nonbookish: me.nonbookish, persuasively: me.persuasively, replaceable: me.replaceable, silex: me.silex, taillight: me.taillight, unjealous: me.unjealous, visitorial: me.visitorial) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + carbonarism: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cineolic: JSONNull?? = nil, + cobbly: JSONNull?? = nil, + conchyliferous: JSONNull?? = nil, + congregation: JSONNull?? = nil, + disdiapason: String?? = nil, + enterotomy: JSONNull?? = nil, + entophytal: JSONNull?? = nil, + fewtrils: JSONNull?? = nil, + herem: JSONNull?? = nil, + homocerc: Bool?? = nil, + koniga: JSONNull?? = nil, + meticulosity: JSONNull?? = nil, + micky: JSONNull?? = nil, + mismarriage: JSONNull?? = nil, + neurotrophic: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + persuasively: JSONNull?? = nil, + replaceable: JSONNull?? = nil, + silex: JSONNull?? = nil, + taillight: JSONNull?? = nil, + unjealous: JSONNull?? = nil, + visitorial: JSONNull?? = nil + ) -> Pneumocele { + return Pneumocele( + carbonarism: carbonarism ?? self.carbonarism, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cineolic: cineolic ?? self.cineolic, + cobbly: cobbly ?? self.cobbly, + conchyliferous: conchyliferous ?? self.conchyliferous, + congregation: congregation ?? self.congregation, + disdiapason: disdiapason ?? self.disdiapason, + enterotomy: enterotomy ?? self.enterotomy, + entophytal: entophytal ?? self.entophytal, + fewtrils: fewtrils ?? self.fewtrils, + herem: herem ?? self.herem, + homocerc: homocerc ?? self.homocerc, + koniga: koniga ?? self.koniga, + meticulosity: meticulosity ?? self.meticulosity, + micky: micky ?? self.micky, + mismarriage: mismarriage ?? self.mismarriage, + neurotrophic: neurotrophic ?? self.neurotrophic, + nonbookish: nonbookish ?? self.nonbookish, + persuasively: persuasively ?? self.persuasively, + replaceable: replaceable ?? self.replaceable, + silex: silex ?? self.silex, + taillight: taillight ?? self.taillight, + unjealous: unjealous ?? self.unjealous, + visitorial: visitorial ?? self.visitorial + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Poliorcetic: Codable, Sendable { + case bool(Bool) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Poormaster: Codable, Sendable { + case integerArray([Int]) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PotwhiskyElement: Codable, Sendable { + case integer(Int) + case potwhiskyClass(PotwhiskyClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PotwhiskyClass.self) { + self = .potwhiskyClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .potwhiskyClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - PotwhiskyClass +final class PotwhiskyClass: Codable, Sendable { + let arciform: JSONNull? + let cresolin: JSONNull? + let disheartener: JSONNull? + let disproportionable: JSONNull? + let euchorda: JSONNull? + let ferryway: JSONNull? + let filamentiferous: JSONNull? + let flemish: JSONNull? + let forgainst: JSONNull? + let grainering: JSONNull? + let irrevoluble: JSONNull? + let kindredship: JSONNull? + let pinguitudinous: JSONNull? + let simpletonic: JSONNull? + let singsong: JSONNull? + let submergement: JSONNull? + let supraoesophagal: JSONNull? + let thrashel: JSONNull? + let tyremesis: JSONNull? + let yoruba: JSONNull? + + enum CodingKeys: String, CodingKey { + case arciform = "arciform" + case cresolin = "cresolin" + case disheartener = "disheartener" + case disproportionable = "disproportionable" + case euchorda = "Euchorda" + case ferryway = "ferryway" + case filamentiferous = "filamentiferous" + case flemish = "flemish" + case forgainst = "forgainst" + case grainering = "grainering" + case irrevoluble = "irrevoluble" + case kindredship = "kindredship" + case pinguitudinous = "pinguitudinous" + case simpletonic = "simpletonic" + case singsong = "singsong" + case submergement = "submergement" + case supraoesophagal = "supraoesophagal" + case thrashel = "thrashel" + case tyremesis = "tyremesis" + case yoruba = "Yoruba" + } + + init(arciform: JSONNull?, cresolin: JSONNull?, disheartener: JSONNull?, disproportionable: JSONNull?, euchorda: JSONNull?, ferryway: JSONNull?, filamentiferous: JSONNull?, flemish: JSONNull?, forgainst: JSONNull?, grainering: JSONNull?, irrevoluble: JSONNull?, kindredship: JSONNull?, pinguitudinous: JSONNull?, simpletonic: JSONNull?, singsong: JSONNull?, submergement: JSONNull?, supraoesophagal: JSONNull?, thrashel: JSONNull?, tyremesis: JSONNull?, yoruba: JSONNull?) { + self.arciform = arciform + self.cresolin = cresolin + self.disheartener = disheartener + self.disproportionable = disproportionable + self.euchorda = euchorda + self.ferryway = ferryway + self.filamentiferous = filamentiferous + self.flemish = flemish + self.forgainst = forgainst + self.grainering = grainering + self.irrevoluble = irrevoluble + self.kindredship = kindredship + self.pinguitudinous = pinguitudinous + self.simpletonic = simpletonic + self.singsong = singsong + self.submergement = submergement + self.supraoesophagal = supraoesophagal + self.thrashel = thrashel + self.tyremesis = tyremesis + self.yoruba = yoruba + } +} + +// MARK: PotwhiskyClass convenience initializers and mutators + +extension PotwhiskyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PotwhiskyClass.self, from: data) + self.init(arciform: me.arciform, cresolin: me.cresolin, disheartener: me.disheartener, disproportionable: me.disproportionable, euchorda: me.euchorda, ferryway: me.ferryway, filamentiferous: me.filamentiferous, flemish: me.flemish, forgainst: me.forgainst, grainering: me.grainering, irrevoluble: me.irrevoluble, kindredship: me.kindredship, pinguitudinous: me.pinguitudinous, simpletonic: me.simpletonic, singsong: me.singsong, submergement: me.submergement, supraoesophagal: me.supraoesophagal, thrashel: me.thrashel, tyremesis: me.tyremesis, yoruba: me.yoruba) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + arciform: JSONNull?? = nil, + cresolin: JSONNull?? = nil, + disheartener: JSONNull?? = nil, + disproportionable: JSONNull?? = nil, + euchorda: JSONNull?? = nil, + ferryway: JSONNull?? = nil, + filamentiferous: JSONNull?? = nil, + flemish: JSONNull?? = nil, + forgainst: JSONNull?? = nil, + grainering: JSONNull?? = nil, + irrevoluble: JSONNull?? = nil, + kindredship: JSONNull?? = nil, + pinguitudinous: JSONNull?? = nil, + simpletonic: JSONNull?? = nil, + singsong: JSONNull?? = nil, + submergement: JSONNull?? = nil, + supraoesophagal: JSONNull?? = nil, + thrashel: JSONNull?? = nil, + tyremesis: JSONNull?? = nil, + yoruba: JSONNull?? = nil + ) -> PotwhiskyClass { + return PotwhiskyClass( + arciform: arciform ?? self.arciform, + cresolin: cresolin ?? self.cresolin, + disheartener: disheartener ?? self.disheartener, + disproportionable: disproportionable ?? self.disproportionable, + euchorda: euchorda ?? self.euchorda, + ferryway: ferryway ?? self.ferryway, + filamentiferous: filamentiferous ?? self.filamentiferous, + flemish: flemish ?? self.flemish, + forgainst: forgainst ?? self.forgainst, + grainering: grainering ?? self.grainering, + irrevoluble: irrevoluble ?? self.irrevoluble, + kindredship: kindredship ?? self.kindredship, + pinguitudinous: pinguitudinous ?? self.pinguitudinous, + simpletonic: simpletonic ?? self.simpletonic, + singsong: singsong ?? self.singsong, + submergement: submergement ?? self.submergement, + supraoesophagal: supraoesophagal ?? self.supraoesophagal, + thrashel: thrashel ?? self.thrashel, + tyremesis: tyremesis ?? self.tyremesis, + yoruba: yoruba ?? self.yoruba + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Practicalizer: Codable, Sendable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum PrefreshmanElement: Codable, Sendable { + case nullArray([JSONNull?]) + case prefreshmanClass(PrefreshmanClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(PrefreshmanClass.self) { + self = .prefreshmanClass(x) + return + } + throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .prefreshmanClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - PrefreshmanClass +final class PrefreshmanClass: Codable, Sendable { + let azorubine: JSONNull? + let choroiditis: JSONNull? + let coagulatory: JSONNull? + let cyclorama: JSONNull? + let dolphus: JSONNull? + let duckhearted: JSONNull? + let ficus: JSONNull? + let gemaric: JSONNull? + let jugation: JSONNull? + let myoliposis: JSONNull? + let nonnomination: JSONNull? + let palay: JSONNull? + let pentactinal: JSONNull? + let phaet: JSONNull? + let piquant: JSONNull? + let registration: JSONNull? + let remancipation: JSONNull? + let scutatiform: JSONNull? + let theodolite: JSONNull? + let underward: JSONNull? + + enum CodingKeys: String, CodingKey { + case azorubine = "azorubine" + case choroiditis = "choroiditis" + case coagulatory = "coagulatory" + case cyclorama = "cyclorama" + case dolphus = "Dolphus" + case duckhearted = "duckhearted" + case ficus = "Ficus" + case gemaric = "Gemaric" + case jugation = "jugation" + case myoliposis = "myoliposis" + case nonnomination = "nonnomination" + case palay = "palay" + case pentactinal = "pentactinal" + case phaet = "Phaet" + case piquant = "piquant" + case registration = "registration" + case remancipation = "remancipation" + case scutatiform = "scutatiform" + case theodolite = "theodolite" + case underward = "underward" + } + + init(azorubine: JSONNull?, choroiditis: JSONNull?, coagulatory: JSONNull?, cyclorama: JSONNull?, dolphus: JSONNull?, duckhearted: JSONNull?, ficus: JSONNull?, gemaric: JSONNull?, jugation: JSONNull?, myoliposis: JSONNull?, nonnomination: JSONNull?, palay: JSONNull?, pentactinal: JSONNull?, phaet: JSONNull?, piquant: JSONNull?, registration: JSONNull?, remancipation: JSONNull?, scutatiform: JSONNull?, theodolite: JSONNull?, underward: JSONNull?) { + self.azorubine = azorubine + self.choroiditis = choroiditis + self.coagulatory = coagulatory + self.cyclorama = cyclorama + self.dolphus = dolphus + self.duckhearted = duckhearted + self.ficus = ficus + self.gemaric = gemaric + self.jugation = jugation + self.myoliposis = myoliposis + self.nonnomination = nonnomination + self.palay = palay + self.pentactinal = pentactinal + self.phaet = phaet + self.piquant = piquant + self.registration = registration + self.remancipation = remancipation + self.scutatiform = scutatiform + self.theodolite = theodolite + self.underward = underward + } +} + +// MARK: PrefreshmanClass convenience initializers and mutators + +extension PrefreshmanClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PrefreshmanClass.self, from: data) + self.init(azorubine: me.azorubine, choroiditis: me.choroiditis, coagulatory: me.coagulatory, cyclorama: me.cyclorama, dolphus: me.dolphus, duckhearted: me.duckhearted, ficus: me.ficus, gemaric: me.gemaric, jugation: me.jugation, myoliposis: me.myoliposis, nonnomination: me.nonnomination, palay: me.palay, pentactinal: me.pentactinal, phaet: me.phaet, piquant: me.piquant, registration: me.registration, remancipation: me.remancipation, scutatiform: me.scutatiform, theodolite: me.theodolite, underward: me.underward) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + azorubine: JSONNull?? = nil, + choroiditis: JSONNull?? = nil, + coagulatory: JSONNull?? = nil, + cyclorama: JSONNull?? = nil, + dolphus: JSONNull?? = nil, + duckhearted: JSONNull?? = nil, + ficus: JSONNull?? = nil, + gemaric: JSONNull?? = nil, + jugation: JSONNull?? = nil, + myoliposis: JSONNull?? = nil, + nonnomination: JSONNull?? = nil, + palay: JSONNull?? = nil, + pentactinal: JSONNull?? = nil, + phaet: JSONNull?? = nil, + piquant: JSONNull?? = nil, + registration: JSONNull?? = nil, + remancipation: JSONNull?? = nil, + scutatiform: JSONNull?? = nil, + theodolite: JSONNull?? = nil, + underward: JSONNull?? = nil + ) -> PrefreshmanClass { + return PrefreshmanClass( + azorubine: azorubine ?? self.azorubine, + choroiditis: choroiditis ?? self.choroiditis, + coagulatory: coagulatory ?? self.coagulatory, + cyclorama: cyclorama ?? self.cyclorama, + dolphus: dolphus ?? self.dolphus, + duckhearted: duckhearted ?? self.duckhearted, + ficus: ficus ?? self.ficus, + gemaric: gemaric ?? self.gemaric, + jugation: jugation ?? self.jugation, + myoliposis: myoliposis ?? self.myoliposis, + nonnomination: nonnomination ?? self.nonnomination, + palay: palay ?? self.palay, + pentactinal: pentactinal ?? self.pentactinal, + phaet: phaet ?? self.phaet, + piquant: piquant ?? self.piquant, + registration: registration ?? self.registration, + remancipation: remancipation ?? self.remancipation, + scutatiform: scutatiform ?? self.scutatiform, + theodolite: theodolite ?? self.theodolite, + underward: underward ?? self.underward + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Prehensility: Codable, Sendable { + case bool(Bool) + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Prevoidance: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Protext: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations4.json/default/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations4.json/default/quicktype.swift new file mode 100644 index 0000000..c167164 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations4.json/default/quicktype.swift @@ -0,0 +1,3641 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Sendable { + let protrusive: [Protrusive] + let pulpitism: [PulpitismElement] + let pyodermia: [PyodermiaElement] + let quebrachine: [QuebrachineElement] + let querier: [Querier] + let rebarbative: [Rebarbative] + let reimagine: [Reimagine] + let ressaut: Ressaut + let retrocervical: [Retrocervical] + let revert: [Revert] + let rewrite: [RewriteElement] + let saccoderm: [Saccoderm] + let santir: [SantirElement] + let saprophilous: [Saprophilous] + let saxten: [SaxtenElement] + let scatty: [Scatty?] + let scoffer: [Scoffer] + let scrampum: [Scrampum] + let semantic: Double + let serpentinic: [Serpentinic] + let shadowable: [Shadowable] + let sistering: [SisteringElement] + let staghunting: [Staghunting] + let stagmometer: [Stagmometer] + let stimulability: [Stimulability] + let strangleable: [Strangleable] + let strenuosity: [StrenuosityElement] + let tabaxir: [Tabaxir] + let talpiform: [Talpiform] + let thwack: [Thwack] + let to: [Double?] + let tortricine: [Tortricine] + let truantcy: [TruantcyElement] + let turgesce: [String] + let unbeginning: [Unbeginning] + let underdunged: [Double] + let undesirability: [Undesirability] + let unerasing: [Unerasing] + let unguentarium: [Unguentarium] + let unimpeachably: [UnimpeachablyElement] + let unmortgaged: [Unmortgaged] + let unobstructed: [Unobstructed] + let unreceptivity: [Unreceptivity] + let unsatisfactoriness: [Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [UnstressedElement] + let untasked: [Untasked] + let unvarying: [Unvarying] + let vehemently: [Vehemently] + let warriorship: [String: Bool] + let whitepot: [Whitepot] + let wrothy: [WrothyElement] + + enum CodingKeys: String, CodingKey { + case protrusive = "protrusive" + case pulpitism = "pulpitism" + case pyodermia = "pyodermia" + case quebrachine = "quebrachine" + case querier = "querier" + case rebarbative = "rebarbative" + case reimagine = "reimagine" + case ressaut = "ressaut" + case retrocervical = "retrocervical" + case revert = "revert" + case rewrite = "rewrite" + case saccoderm = "saccoderm" + case santir = "santir" + case saprophilous = "saprophilous" + case saxten = "saxten" + case scatty = "scatty" + case scoffer = "scoffer" + case scrampum = "scrampum" + case semantic = "semantic" + case serpentinic = "serpentinic" + case shadowable = "shadowable" + case sistering = "sistering" + case staghunting = "staghunting" + case stagmometer = "stagmometer" + case stimulability = "stimulability" + case strangleable = "strangleable" + case strenuosity = "strenuosity" + case tabaxir = "tabaxir" + case talpiform = "talpiform" + case thwack = "thwack" + case to = "to" + case tortricine = "tortricine" + case truantcy = "truantcy" + case turgesce = "turgesce" + case unbeginning = "unbeginning" + case underdunged = "underdunged" + case undesirability = "undesirability" + case unerasing = "unerasing" + case unguentarium = "unguentarium" + case unimpeachably = "unimpeachably" + case unmortgaged = "unmortgaged" + case unobstructed = "unobstructed" + case unreceptivity = "unreceptivity" + case unsatisfactoriness = "unsatisfactoriness" + case unsecurity = "unsecurity" + case unstressed = "unstressed" + case untasked = "untasked" + case unvarying = "unvarying" + case vehemently = "vehemently" + case warriorship = "warriorship" + case whitepot = "whitepot" + case wrothy = "wrothy" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + protrusive: [Protrusive]? = nil, + pulpitism: [PulpitismElement]? = nil, + pyodermia: [PyodermiaElement]? = nil, + quebrachine: [QuebrachineElement]? = nil, + querier: [Querier]? = nil, + rebarbative: [Rebarbative]? = nil, + reimagine: [Reimagine]? = nil, + ressaut: Ressaut? = nil, + retrocervical: [Retrocervical]? = nil, + revert: [Revert]? = nil, + rewrite: [RewriteElement]? = nil, + saccoderm: [Saccoderm]? = nil, + santir: [SantirElement]? = nil, + saprophilous: [Saprophilous]? = nil, + saxten: [SaxtenElement]? = nil, + scatty: [Scatty?]? = nil, + scoffer: [Scoffer]? = nil, + scrampum: [Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [Serpentinic]? = nil, + shadowable: [Shadowable]? = nil, + sistering: [SisteringElement]? = nil, + staghunting: [Staghunting]? = nil, + stagmometer: [Stagmometer]? = nil, + stimulability: [Stimulability]? = nil, + strangleable: [Strangleable]? = nil, + strenuosity: [StrenuosityElement]? = nil, + tabaxir: [Tabaxir]? = nil, + talpiform: [Talpiform]? = nil, + thwack: [Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [Tortricine]? = nil, + truantcy: [TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [Undesirability]? = nil, + unerasing: [Unerasing]? = nil, + unguentarium: [Unguentarium]? = nil, + unimpeachably: [UnimpeachablyElement]? = nil, + unmortgaged: [Unmortgaged]? = nil, + unobstructed: [Unobstructed]? = nil, + unreceptivity: [Unreceptivity]? = nil, + unsatisfactoriness: [Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [UnstressedElement]? = nil, + untasked: [Untasked]? = nil, + unvarying: [Unvarying]? = nil, + vehemently: [Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [Whitepot]? = nil, + wrothy: [WrothyElement]? = nil + ) -> TopLevel { + return TopLevel( + protrusive: protrusive ?? self.protrusive, + pulpitism: pulpitism ?? self.pulpitism, + pyodermia: pyodermia ?? self.pyodermia, + quebrachine: quebrachine ?? self.quebrachine, + querier: querier ?? self.querier, + rebarbative: rebarbative ?? self.rebarbative, + reimagine: reimagine ?? self.reimagine, + ressaut: ressaut ?? self.ressaut, + retrocervical: retrocervical ?? self.retrocervical, + revert: revert ?? self.revert, + rewrite: rewrite ?? self.rewrite, + saccoderm: saccoderm ?? self.saccoderm, + santir: santir ?? self.santir, + saprophilous: saprophilous ?? self.saprophilous, + saxten: saxten ?? self.saxten, + scatty: scatty ?? self.scatty, + scoffer: scoffer ?? self.scoffer, + scrampum: scrampum ?? self.scrampum, + semantic: semantic ?? self.semantic, + serpentinic: serpentinic ?? self.serpentinic, + shadowable: shadowable ?? self.shadowable, + sistering: sistering ?? self.sistering, + staghunting: staghunting ?? self.staghunting, + stagmometer: stagmometer ?? self.stagmometer, + stimulability: stimulability ?? self.stimulability, + strangleable: strangleable ?? self.strangleable, + strenuosity: strenuosity ?? self.strenuosity, + tabaxir: tabaxir ?? self.tabaxir, + talpiform: talpiform ?? self.talpiform, + thwack: thwack ?? self.thwack, + to: to ?? self.to, + tortricine: tortricine ?? self.tortricine, + truantcy: truantcy ?? self.truantcy, + turgesce: turgesce ?? self.turgesce, + unbeginning: unbeginning ?? self.unbeginning, + underdunged: underdunged ?? self.underdunged, + undesirability: undesirability ?? self.undesirability, + unerasing: unerasing ?? self.unerasing, + unguentarium: unguentarium ?? self.unguentarium, + unimpeachably: unimpeachably ?? self.unimpeachably, + unmortgaged: unmortgaged ?? self.unmortgaged, + unobstructed: unobstructed ?? self.unobstructed, + unreceptivity: unreceptivity ?? self.unreceptivity, + unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness, + unsecurity: unsecurity ?? self.unsecurity, + unstressed: unstressed ?? self.unstressed, + untasked: untasked ?? self.untasked, + unvarying: unvarying ?? self.unvarying, + vehemently: vehemently ?? self.vehemently, + warriorship: warriorship ?? self.warriorship, + whitepot: whitepot ?? self.whitepot, + wrothy: wrothy ?? self.wrothy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Protrusive: Codable, Sendable { + case double(Double) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum PulpitismElement: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case pulpitismClass(PulpitismClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PulpitismClass.self) { + self = .pulpitismClass(x) + return + } + throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .pulpitismClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PulpitismClass +struct PulpitismClass: Codable, Sendable { + let abnet: JSONNull? + let buckhorn: JSONNull? + let calciform: JSONNull? + let chelophore: JSONNull? + let cogitation: JSONNull? + let decreeable: JSONNull? + let despicable: JSONNull? + let isodiazo: JSONNull? + let jadedly: JSONNull? + let leptochlorite: JSONNull? + let nursling: JSONNull? + let palamedean: JSONNull? + let photoheliograph: JSONNull? + let pipewood: JSONNull? + let roberd: JSONNull? + let statable: JSONNull? + let superassume: JSONNull? + let syllabe: JSONNull? + let toughhead: JSONNull? + let underburn: JSONNull? + + enum CodingKeys: String, CodingKey { + case abnet = "abnet" + case buckhorn = "buckhorn" + case calciform = "calciform" + case chelophore = "chelophore" + case cogitation = "cogitation" + case decreeable = "decreeable" + case despicable = "despicable" + case isodiazo = "isodiazo" + case jadedly = "jadedly" + case leptochlorite = "leptochlorite" + case nursling = "nursling" + case palamedean = "palamedean" + case photoheliograph = "photoheliograph" + case pipewood = "pipewood" + case roberd = "roberd" + case statable = "statable" + case superassume = "superassume" + case syllabe = "syllabe" + case toughhead = "toughhead" + case underburn = "underburn" + } +} + +// MARK: PulpitismClass convenience initializers and mutators + +extension PulpitismClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PulpitismClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abnet: JSONNull?? = nil, + buckhorn: JSONNull?? = nil, + calciform: JSONNull?? = nil, + chelophore: JSONNull?? = nil, + cogitation: JSONNull?? = nil, + decreeable: JSONNull?? = nil, + despicable: JSONNull?? = nil, + isodiazo: JSONNull?? = nil, + jadedly: JSONNull?? = nil, + leptochlorite: JSONNull?? = nil, + nursling: JSONNull?? = nil, + palamedean: JSONNull?? = nil, + photoheliograph: JSONNull?? = nil, + pipewood: JSONNull?? = nil, + roberd: JSONNull?? = nil, + statable: JSONNull?? = nil, + superassume: JSONNull?? = nil, + syllabe: JSONNull?? = nil, + toughhead: JSONNull?? = nil, + underburn: JSONNull?? = nil + ) -> PulpitismClass { + return PulpitismClass( + abnet: abnet ?? self.abnet, + buckhorn: buckhorn ?? self.buckhorn, + calciform: calciform ?? self.calciform, + chelophore: chelophore ?? self.chelophore, + cogitation: cogitation ?? self.cogitation, + decreeable: decreeable ?? self.decreeable, + despicable: despicable ?? self.despicable, + isodiazo: isodiazo ?? self.isodiazo, + jadedly: jadedly ?? self.jadedly, + leptochlorite: leptochlorite ?? self.leptochlorite, + nursling: nursling ?? self.nursling, + palamedean: palamedean ?? self.palamedean, + photoheliograph: photoheliograph ?? self.photoheliograph, + pipewood: pipewood ?? self.pipewood, + roberd: roberd ?? self.roberd, + statable: statable ?? self.statable, + superassume: superassume ?? self.superassume, + syllabe: syllabe ?? self.syllabe, + toughhead: toughhead ?? self.toughhead, + underburn: underburn ?? self.underburn + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum PyodermiaElement: Codable, Sendable { + case integer(Int) + case pyodermiaClass(PyodermiaClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PyodermiaClass.self) { + self = .pyodermiaClass(x) + return + } + throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .pyodermiaClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PyodermiaClass +struct PyodermiaClass: Codable, Sendable { + let aphoristically: JSONNull? + let apophyllous: JSONNull? + let cognize: JSONNull? + let dermonosology: JSONNull? + let gyppo: JSONNull? + let ither: JSONNull? + let juglandaceous: JSONNull? + let litho: JSONNull? + let macropterous: JSONNull? + let photographer: JSONNull? + let romancing: JSONNull? + let rumness: JSONNull? + let somniloquist: JSONNull? + let stressfully: JSONNull? + let tactically: JSONNull? + let tracheophony: JSONNull? + let unappositely: JSONNull? + let unclothedly: JSONNull? + let unimplied: JSONNull? + let unsyncopated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aphoristically = "aphoristically" + case apophyllous = "apophyllous" + case cognize = "cognize" + case dermonosology = "dermonosology" + case gyppo = "Gyppo" + case ither = "ither" + case juglandaceous = "juglandaceous" + case litho = "litho" + case macropterous = "macropterous" + case photographer = "photographer" + case romancing = "romancing" + case rumness = "rumness" + case somniloquist = "somniloquist" + case stressfully = "stressfully" + case tactically = "tactically" + case tracheophony = "tracheophony" + case unappositely = "unappositely" + case unclothedly = "unclothedly" + case unimplied = "unimplied" + case unsyncopated = "unsyncopated" + } +} + +// MARK: PyodermiaClass convenience initializers and mutators + +extension PyodermiaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PyodermiaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aphoristically: JSONNull?? = nil, + apophyllous: JSONNull?? = nil, + cognize: JSONNull?? = nil, + dermonosology: JSONNull?? = nil, + gyppo: JSONNull?? = nil, + ither: JSONNull?? = nil, + juglandaceous: JSONNull?? = nil, + litho: JSONNull?? = nil, + macropterous: JSONNull?? = nil, + photographer: JSONNull?? = nil, + romancing: JSONNull?? = nil, + rumness: JSONNull?? = nil, + somniloquist: JSONNull?? = nil, + stressfully: JSONNull?? = nil, + tactically: JSONNull?? = nil, + tracheophony: JSONNull?? = nil, + unappositely: JSONNull?? = nil, + unclothedly: JSONNull?? = nil, + unimplied: JSONNull?? = nil, + unsyncopated: JSONNull?? = nil + ) -> PyodermiaClass { + return PyodermiaClass( + aphoristically: aphoristically ?? self.aphoristically, + apophyllous: apophyllous ?? self.apophyllous, + cognize: cognize ?? self.cognize, + dermonosology: dermonosology ?? self.dermonosology, + gyppo: gyppo ?? self.gyppo, + ither: ither ?? self.ither, + juglandaceous: juglandaceous ?? self.juglandaceous, + litho: litho ?? self.litho, + macropterous: macropterous ?? self.macropterous, + photographer: photographer ?? self.photographer, + romancing: romancing ?? self.romancing, + rumness: rumness ?? self.rumness, + somniloquist: somniloquist ?? self.somniloquist, + stressfully: stressfully ?? self.stressfully, + tactically: tactically ?? self.tactically, + tracheophony: tracheophony ?? self.tracheophony, + unappositely: unappositely ?? self.unappositely, + unclothedly: unclothedly ?? self.unclothedly, + unimplied: unimplied ?? self.unimplied, + unsyncopated: unsyncopated ?? self.unsyncopated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum QuebrachineElement: Codable, Sendable { + case bool(Bool) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - QuebrachineClass +struct QuebrachineClass: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: QuebrachineClass convenience initializers and mutators + +extension QuebrachineClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(QuebrachineClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> QuebrachineClass { + return QuebrachineClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Querier: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Rebarbative: Codable, Sendable { + case bool(Bool) + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - Reimagine +struct Reimagine: Codable, Sendable { + let adducible: JSONNull? + let anabolin: JSONNull? + let brainy: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let chrysamine: JSONNull? + let disdiapason: String? + let fluxweed: JSONNull? + let glaucine: JSONNull? + let grobianism: JSONNull? + let hermo: JSONNull? + let hieroglyphist: JSONNull? + let homocerc: Bool? + let icteroid: JSONNull? + let immortal: JSONNull? + let impetulant: JSONNull? + let irrigate: JSONNull? + let myxedema: JSONNull? + let nonbookish: JSONNull? + let onyx: JSONNull? + let repasser: JSONNull? + let septomarginal: JSONNull? + let subdie: JSONNull? + let tibiometatarsal: JSONNull? + let waltzlike: JSONNull? + + enum CodingKeys: String, CodingKey { + case adducible = "adducible" + case anabolin = "anabolin" + case brainy = "brainy" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chrysamine = "chrysamine" + case disdiapason = "disdiapason" + case fluxweed = "fluxweed" + case glaucine = "glaucine" + case grobianism = "grobianism" + case hermo = "Hermo" + case hieroglyphist = "hieroglyphist" + case homocerc = "homocerc" + case icteroid = "icteroid" + case immortal = "immortal" + case impetulant = "impetulant" + case irrigate = "irrigate" + case myxedema = "myxedema" + case nonbookish = "nonbookish" + case onyx = "onyx" + case repasser = "repasser" + case septomarginal = "septomarginal" + case subdie = "subdie" + case tibiometatarsal = "tibiometatarsal" + case waltzlike = "waltzlike" + } +} + +// MARK: Reimagine convenience initializers and mutators + +extension Reimagine { + init(data: Data) throws { + self = try newJSONDecoder().decode(Reimagine.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adducible: JSONNull?? = nil, + anabolin: JSONNull?? = nil, + brainy: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chrysamine: JSONNull?? = nil, + disdiapason: String?? = nil, + fluxweed: JSONNull?? = nil, + glaucine: JSONNull?? = nil, + grobianism: JSONNull?? = nil, + hermo: JSONNull?? = nil, + hieroglyphist: JSONNull?? = nil, + homocerc: Bool?? = nil, + icteroid: JSONNull?? = nil, + immortal: JSONNull?? = nil, + impetulant: JSONNull?? = nil, + irrigate: JSONNull?? = nil, + myxedema: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + onyx: JSONNull?? = nil, + repasser: JSONNull?? = nil, + septomarginal: JSONNull?? = nil, + subdie: JSONNull?? = nil, + tibiometatarsal: JSONNull?? = nil, + waltzlike: JSONNull?? = nil + ) -> Reimagine { + return Reimagine( + adducible: adducible ?? self.adducible, + anabolin: anabolin ?? self.anabolin, + brainy: brainy ?? self.brainy, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chrysamine: chrysamine ?? self.chrysamine, + disdiapason: disdiapason ?? self.disdiapason, + fluxweed: fluxweed ?? self.fluxweed, + glaucine: glaucine ?? self.glaucine, + grobianism: grobianism ?? self.grobianism, + hermo: hermo ?? self.hermo, + hieroglyphist: hieroglyphist ?? self.hieroglyphist, + homocerc: homocerc ?? self.homocerc, + icteroid: icteroid ?? self.icteroid, + immortal: immortal ?? self.immortal, + impetulant: impetulant ?? self.impetulant, + irrigate: irrigate ?? self.irrigate, + myxedema: myxedema ?? self.myxedema, + nonbookish: nonbookish ?? self.nonbookish, + onyx: onyx ?? self.onyx, + repasser: repasser ?? self.repasser, + septomarginal: septomarginal ?? self.septomarginal, + subdie: subdie ?? self.subdie, + tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal, + waltzlike: waltzlike ?? self.waltzlike + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Ressaut +struct Ressaut: Codable, Sendable { + let apperceptive: String + let cuttoo: String + let douser: String + let drinkproof: String + let forementioned: String + let freesia: String + let genevieve: String + let hyperdiabolical: String + let hypocone: String + let irreverentially: String + let jumart: String + let mimosaceae: String + let mollicrush: String + let nedder: String + let retinasphalt: String + let sough: String + let steading: String + let theopaschitism: String + let undurableness: String + let unmingleable: String + + enum CodingKeys: String, CodingKey { + case apperceptive = "apperceptive" + case cuttoo = "cuttoo" + case douser = "douser" + case drinkproof = "drinkproof" + case forementioned = "forementioned" + case freesia = "Freesia" + case genevieve = "Genevieve" + case hyperdiabolical = "hyperdiabolical" + case hypocone = "hypocone" + case irreverentially = "irreverentially" + case jumart = "jumart" + case mimosaceae = "Mimosaceae" + case mollicrush = "mollicrush" + case nedder = "nedder" + case retinasphalt = "retinasphalt" + case sough = "sough" + case steading = "steading" + case theopaschitism = "Theopaschitism" + case undurableness = "undurableness" + case unmingleable = "unmingleable" + } +} + +// MARK: Ressaut convenience initializers and mutators + +extension Ressaut { + init(data: Data) throws { + self = try newJSONDecoder().decode(Ressaut.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apperceptive: String? = nil, + cuttoo: String? = nil, + douser: String? = nil, + drinkproof: String? = nil, + forementioned: String? = nil, + freesia: String? = nil, + genevieve: String? = nil, + hyperdiabolical: String? = nil, + hypocone: String? = nil, + irreverentially: String? = nil, + jumart: String? = nil, + mimosaceae: String? = nil, + mollicrush: String? = nil, + nedder: String? = nil, + retinasphalt: String? = nil, + sough: String? = nil, + steading: String? = nil, + theopaschitism: String? = nil, + undurableness: String? = nil, + unmingleable: String? = nil + ) -> Ressaut { + return Ressaut( + apperceptive: apperceptive ?? self.apperceptive, + cuttoo: cuttoo ?? self.cuttoo, + douser: douser ?? self.douser, + drinkproof: drinkproof ?? self.drinkproof, + forementioned: forementioned ?? self.forementioned, + freesia: freesia ?? self.freesia, + genevieve: genevieve ?? self.genevieve, + hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical, + hypocone: hypocone ?? self.hypocone, + irreverentially: irreverentially ?? self.irreverentially, + jumart: jumart ?? self.jumart, + mimosaceae: mimosaceae ?? self.mimosaceae, + mollicrush: mollicrush ?? self.mollicrush, + nedder: nedder ?? self.nedder, + retinasphalt: retinasphalt ?? self.retinasphalt, + sough: sough ?? self.sough, + steading: steading ?? self.steading, + theopaschitism: theopaschitism ?? self.theopaschitism, + undurableness: undurableness ?? self.undurableness, + unmingleable: unmingleable ?? self.unmingleable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Retrocervical: Codable, Sendable { + case integer(Int) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Revert: Codable, Sendable { + case bool(Bool) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum RewriteElement: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + case rewriteClass(RewriteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(RewriteClass.self) { + self = .rewriteClass(x) + return + } + throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .rewriteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - RewriteClass +struct RewriteClass: Codable, Sendable { + let accountancy: JSONNull? + let cacotrophic: JSONNull? + let contest: JSONNull? + let couthily: JSONNull? + let falculate: JSONNull? + let foreseize: JSONNull? + let hyades: JSONNull? + let lemnad: JSONNull? + let monotheistically: JSONNull? + let nonflying: JSONNull? + let ptenoglossa: JSONNull? + let repatch: JSONNull? + let rodman: JSONNull? + let strung: JSONNull? + let titmal: JSONNull? + let twalpennyworth: JSONNull? + let unblamable: JSONNull? + let vertical: JSONNull? + let whiggification: JSONNull? + let yardman: JSONNull? + + enum CodingKeys: String, CodingKey { + case accountancy = "accountancy" + case cacotrophic = "cacotrophic" + case contest = "contest" + case couthily = "couthily" + case falculate = "falculate" + case foreseize = "foreseize" + case hyades = "Hyades" + case lemnad = "lemnad" + case monotheistically = "monotheistically" + case nonflying = "nonflying" + case ptenoglossa = "Ptenoglossa" + case repatch = "repatch" + case rodman = "rodman" + case strung = "strung" + case titmal = "titmal" + case twalpennyworth = "twalpennyworth" + case unblamable = "unblamable" + case vertical = "vertical" + case whiggification = "Whiggification" + case yardman = "yardman" + } +} + +// MARK: RewriteClass convenience initializers and mutators + +extension RewriteClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(RewriteClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accountancy: JSONNull?? = nil, + cacotrophic: JSONNull?? = nil, + contest: JSONNull?? = nil, + couthily: JSONNull?? = nil, + falculate: JSONNull?? = nil, + foreseize: JSONNull?? = nil, + hyades: JSONNull?? = nil, + lemnad: JSONNull?? = nil, + monotheistically: JSONNull?? = nil, + nonflying: JSONNull?? = nil, + ptenoglossa: JSONNull?? = nil, + repatch: JSONNull?? = nil, + rodman: JSONNull?? = nil, + strung: JSONNull?? = nil, + titmal: JSONNull?? = nil, + twalpennyworth: JSONNull?? = nil, + unblamable: JSONNull?? = nil, + vertical: JSONNull?? = nil, + whiggification: JSONNull?? = nil, + yardman: JSONNull?? = nil + ) -> RewriteClass { + return RewriteClass( + accountancy: accountancy ?? self.accountancy, + cacotrophic: cacotrophic ?? self.cacotrophic, + contest: contest ?? self.contest, + couthily: couthily ?? self.couthily, + falculate: falculate ?? self.falculate, + foreseize: foreseize ?? self.foreseize, + hyades: hyades ?? self.hyades, + lemnad: lemnad ?? self.lemnad, + monotheistically: monotheistically ?? self.monotheistically, + nonflying: nonflying ?? self.nonflying, + ptenoglossa: ptenoglossa ?? self.ptenoglossa, + repatch: repatch ?? self.repatch, + rodman: rodman ?? self.rodman, + strung: strung ?? self.strung, + titmal: titmal ?? self.titmal, + twalpennyworth: twalpennyworth ?? self.twalpennyworth, + unblamable: unblamable ?? self.unblamable, + vertical: vertical ?? self.vertical, + whiggification: whiggification ?? self.whiggification, + yardman: yardman ?? self.yardman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saccoderm: Codable, Sendable { + case integerArray([Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SantirElement: Codable, Sendable { + case double(Double) + case santirClass(SantirClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(SantirClass.self) { + self = .santirClass(x) + return + } + throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .santirClass(let x): + try container.encode(x) + } + } +} + +// MARK: - SantirClass +struct SantirClass: Codable, Sendable { + let admiredly: JSONNull? + let demicaponier: JSONNull? + let epitympanic: JSONNull? + let investitor: JSONNull? + let lupiform: JSONNull? + let monoflagellate: JSONNull? + let paleoethnic: JSONNull? + let prediscountable: JSONNull? + let rhetoricals: JSONNull? + let roomth: JSONNull? + let saccharose: JSONNull? + let septonasal: JSONNull? + let serpenticide: JSONNull? + let setarious: JSONNull? + let spaework: JSONNull? + let stylite: JSONNull? + let suessiones: JSONNull? + let timelily: JSONNull? + let unprofaned: JSONNull? + let vorticular: JSONNull? + + enum CodingKeys: String, CodingKey { + case admiredly = "admiredly" + case demicaponier = "demicaponier" + case epitympanic = "epitympanic" + case investitor = "investitor" + case lupiform = "lupiform" + case monoflagellate = "monoflagellate" + case paleoethnic = "paleoethnic" + case prediscountable = "prediscountable" + case rhetoricals = "rhetoricals" + case roomth = "roomth" + case saccharose = "saccharose" + case septonasal = "septonasal" + case serpenticide = "serpenticide" + case setarious = "setarious" + case spaework = "spaework" + case stylite = "stylite" + case suessiones = "Suessiones" + case timelily = "timelily" + case unprofaned = "unprofaned" + case vorticular = "vorticular" + } +} + +// MARK: SantirClass convenience initializers and mutators + +extension SantirClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(SantirClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + admiredly: JSONNull?? = nil, + demicaponier: JSONNull?? = nil, + epitympanic: JSONNull?? = nil, + investitor: JSONNull?? = nil, + lupiform: JSONNull?? = nil, + monoflagellate: JSONNull?? = nil, + paleoethnic: JSONNull?? = nil, + prediscountable: JSONNull?? = nil, + rhetoricals: JSONNull?? = nil, + roomth: JSONNull?? = nil, + saccharose: JSONNull?? = nil, + septonasal: JSONNull?? = nil, + serpenticide: JSONNull?? = nil, + setarious: JSONNull?? = nil, + spaework: JSONNull?? = nil, + stylite: JSONNull?? = nil, + suessiones: JSONNull?? = nil, + timelily: JSONNull?? = nil, + unprofaned: JSONNull?? = nil, + vorticular: JSONNull?? = nil + ) -> SantirClass { + return SantirClass( + admiredly: admiredly ?? self.admiredly, + demicaponier: demicaponier ?? self.demicaponier, + epitympanic: epitympanic ?? self.epitympanic, + investitor: investitor ?? self.investitor, + lupiform: lupiform ?? self.lupiform, + monoflagellate: monoflagellate ?? self.monoflagellate, + paleoethnic: paleoethnic ?? self.paleoethnic, + prediscountable: prediscountable ?? self.prediscountable, + rhetoricals: rhetoricals ?? self.rhetoricals, + roomth: roomth ?? self.roomth, + saccharose: saccharose ?? self.saccharose, + septonasal: septonasal ?? self.septonasal, + serpenticide: serpenticide ?? self.serpenticide, + setarious: setarious ?? self.setarious, + spaework: spaework ?? self.spaework, + stylite: stylite ?? self.stylite, + suessiones: suessiones ?? self.suessiones, + timelily: timelily ?? self.timelily, + unprofaned: unprofaned ?? self.unprofaned, + vorticular: vorticular ?? self.vorticular + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saprophilous: Codable, Sendable { + case integerMap([String: Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SaxtenElement: Codable, Sendable { + case saxtenClass(SaxtenClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(SaxtenClass.self) { + self = .saxtenClass(x) + return + } + throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .saxtenClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - SaxtenClass +struct SaxtenClass: Codable, Sendable { + let algarrobilla: JSONNull? + let bowgrace: JSONNull? + let catharticalness: Double? + let centaurid: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let flix: JSONNull? + let germanely: JSONNull? + let homocerc: Bool? + let inhume: JSONNull? + let lepidote: JSONNull? + let megalochirous: JSONNull? + let ninepenny: JSONNull? + let nonbookish: JSONNull? + let nondeist: JSONNull? + let nymphaeaceous: JSONNull? + let parietofrontal: JSONNull? + let sancyite: JSONNull? + let subjectivist: JSONNull? + let tibiad: JSONNull? + let transonic: JSONNull? + let tripetalous: JSONNull? + let trunchman: JSONNull? + let urger: JSONNull? + let withdrawnness: JSONNull? + + enum CodingKeys: String, CodingKey { + case algarrobilla = "algarrobilla" + case bowgrace = "bowgrace" + case catharticalness = "catharticalness" + case centaurid = "Centaurid" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case flix = "flix" + case germanely = "germanely" + case homocerc = "homocerc" + case inhume = "inhume" + case lepidote = "lepidote" + case megalochirous = "megalochirous" + case ninepenny = "ninepenny" + case nonbookish = "nonbookish" + case nondeist = "nondeist" + case nymphaeaceous = "nymphaeaceous" + case parietofrontal = "parietofrontal" + case sancyite = "sancyite" + case subjectivist = "subjectivist" + case tibiad = "tibiad" + case transonic = "transonic" + case tripetalous = "tripetalous" + case trunchman = "trunchman" + case urger = "urger" + case withdrawnness = "withdrawnness" + } +} + +// MARK: SaxtenClass convenience initializers and mutators + +extension SaxtenClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(SaxtenClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + algarrobilla: JSONNull?? = nil, + bowgrace: JSONNull?? = nil, + catharticalness: Double?? = nil, + centaurid: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + flix: JSONNull?? = nil, + germanely: JSONNull?? = nil, + homocerc: Bool?? = nil, + inhume: JSONNull?? = nil, + lepidote: JSONNull?? = nil, + megalochirous: JSONNull?? = nil, + ninepenny: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nondeist: JSONNull?? = nil, + nymphaeaceous: JSONNull?? = nil, + parietofrontal: JSONNull?? = nil, + sancyite: JSONNull?? = nil, + subjectivist: JSONNull?? = nil, + tibiad: JSONNull?? = nil, + transonic: JSONNull?? = nil, + tripetalous: JSONNull?? = nil, + trunchman: JSONNull?? = nil, + urger: JSONNull?? = nil, + withdrawnness: JSONNull?? = nil + ) -> SaxtenClass { + return SaxtenClass( + algarrobilla: algarrobilla ?? self.algarrobilla, + bowgrace: bowgrace ?? self.bowgrace, + catharticalness: catharticalness ?? self.catharticalness, + centaurid: centaurid ?? self.centaurid, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + flix: flix ?? self.flix, + germanely: germanely ?? self.germanely, + homocerc: homocerc ?? self.homocerc, + inhume: inhume ?? self.inhume, + lepidote: lepidote ?? self.lepidote, + megalochirous: megalochirous ?? self.megalochirous, + ninepenny: ninepenny ?? self.ninepenny, + nonbookish: nonbookish ?? self.nonbookish, + nondeist: nondeist ?? self.nondeist, + nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous, + parietofrontal: parietofrontal ?? self.parietofrontal, + sancyite: sancyite ?? self.sancyite, + subjectivist: subjectivist ?? self.subjectivist, + tibiad: tibiad ?? self.tibiad, + transonic: transonic ?? self.transonic, + tripetalous: tripetalous ?? self.tripetalous, + trunchman: trunchman ?? self.trunchman, + urger: urger ?? self.urger, + withdrawnness: withdrawnness ?? self.withdrawnness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Scatty +struct Scatty: Codable, Sendable { + let aeriferous: JSONNull? + let antical: JSONNull? + let antighostism: JSONNull? + let arcanum: JSONNull? + let autotrophy: JSONNull? + let baronial: JSONNull? + let caffeine: JSONNull? + let gorgoniacean: JSONNull? + let heroical: JSONNull? + let hydropical: JSONNull? + let mechanology: JSONNull? + let musicopoetic: JSONNull? + let officiality: JSONNull? + let oftentimes: JSONNull? + let ophthalmotonometer: JSONNull? + let reflectively: JSONNull? + let springer: JSONNull? + let tabasco: JSONNull? + let teleianthous: JSONNull? + let uncombated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeriferous = "aeriferous" + case antical = "antical" + case antighostism = "antighostism" + case arcanum = "arcanum" + case autotrophy = "autotrophy" + case baronial = "baronial" + case caffeine = "caffeine" + case gorgoniacean = "gorgoniacean" + case heroical = "heroical" + case hydropical = "hydropical" + case mechanology = "mechanology" + case musicopoetic = "musicopoetic" + case officiality = "officiality" + case oftentimes = "oftentimes" + case ophthalmotonometer = "ophthalmotonometer" + case reflectively = "reflectively" + case springer = "springer" + case tabasco = "Tabasco" + case teleianthous = "teleianthous" + case uncombated = "uncombated" + } +} + +// MARK: Scatty convenience initializers and mutators + +extension Scatty { + init(data: Data) throws { + self = try newJSONDecoder().decode(Scatty.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeriferous: JSONNull?? = nil, + antical: JSONNull?? = nil, + antighostism: JSONNull?? = nil, + arcanum: JSONNull?? = nil, + autotrophy: JSONNull?? = nil, + baronial: JSONNull?? = nil, + caffeine: JSONNull?? = nil, + gorgoniacean: JSONNull?? = nil, + heroical: JSONNull?? = nil, + hydropical: JSONNull?? = nil, + mechanology: JSONNull?? = nil, + musicopoetic: JSONNull?? = nil, + officiality: JSONNull?? = nil, + oftentimes: JSONNull?? = nil, + ophthalmotonometer: JSONNull?? = nil, + reflectively: JSONNull?? = nil, + springer: JSONNull?? = nil, + tabasco: JSONNull?? = nil, + teleianthous: JSONNull?? = nil, + uncombated: JSONNull?? = nil + ) -> Scatty { + return Scatty( + aeriferous: aeriferous ?? self.aeriferous, + antical: antical ?? self.antical, + antighostism: antighostism ?? self.antighostism, + arcanum: arcanum ?? self.arcanum, + autotrophy: autotrophy ?? self.autotrophy, + baronial: baronial ?? self.baronial, + caffeine: caffeine ?? self.caffeine, + gorgoniacean: gorgoniacean ?? self.gorgoniacean, + heroical: heroical ?? self.heroical, + hydropical: hydropical ?? self.hydropical, + mechanology: mechanology ?? self.mechanology, + musicopoetic: musicopoetic ?? self.musicopoetic, + officiality: officiality ?? self.officiality, + oftentimes: oftentimes ?? self.oftentimes, + ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer, + reflectively: reflectively ?? self.reflectively, + springer: springer ?? self.springer, + tabasco: tabasco ?? self.tabasco, + teleianthous: teleianthous ?? self.teleianthous, + uncombated: uncombated ?? self.uncombated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Scoffer: Codable, Sendable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Scrampum: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Serpentinic: Codable, Sendable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Shadowable: Codable, Sendable { + case bool(Bool) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum SisteringElement: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + case sisteringClass(SisteringClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(SisteringClass.self) { + self = .sisteringClass(x) + return + } + throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .sisteringClass(let x): + try container.encode(x) + } + } +} + +// MARK: - SisteringClass +struct SisteringClass: Codable, Sendable { + let amphicarpic: JSONNull? + let chianti: JSONNull? + let frigorific: JSONNull? + let haplomi: JSONNull? + let hyperkinesis: JSONNull? + let laudable: JSONNull? + let madwoman: JSONNull? + let maimedly: JSONNull? + let micropterygidae: JSONNull? + let microrhabdus: JSONNull? + let nondense: JSONNull? + let phlebemphraxis: JSONNull? + let redsear: JSONNull? + let schismatical: JSONNull? + let tartryl: JSONNull? + let unabhorred: JSONNull? + let undeliberateness: JSONNull? + let unmixable: JSONNull? + let untruckling: JSONNull? + let vineal: JSONNull? + + enum CodingKeys: String, CodingKey { + case amphicarpic = "amphicarpic" + case chianti = "Chianti" + case frigorific = "frigorific" + case haplomi = "Haplomi" + case hyperkinesis = "hyperkinesis" + case laudable = "laudable" + case madwoman = "madwoman" + case maimedly = "maimedly" + case micropterygidae = "Micropterygidae" + case microrhabdus = "microrhabdus" + case nondense = "nondense" + case phlebemphraxis = "phlebemphraxis" + case redsear = "redsear" + case schismatical = "schismatical" + case tartryl = "tartryl" + case unabhorred = "unabhorred" + case undeliberateness = "undeliberateness" + case unmixable = "unmixable" + case untruckling = "untruckling" + case vineal = "vineal" + } +} + +// MARK: SisteringClass convenience initializers and mutators + +extension SisteringClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(SisteringClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amphicarpic: JSONNull?? = nil, + chianti: JSONNull?? = nil, + frigorific: JSONNull?? = nil, + haplomi: JSONNull?? = nil, + hyperkinesis: JSONNull?? = nil, + laudable: JSONNull?? = nil, + madwoman: JSONNull?? = nil, + maimedly: JSONNull?? = nil, + micropterygidae: JSONNull?? = nil, + microrhabdus: JSONNull?? = nil, + nondense: JSONNull?? = nil, + phlebemphraxis: JSONNull?? = nil, + redsear: JSONNull?? = nil, + schismatical: JSONNull?? = nil, + tartryl: JSONNull?? = nil, + unabhorred: JSONNull?? = nil, + undeliberateness: JSONNull?? = nil, + unmixable: JSONNull?? = nil, + untruckling: JSONNull?? = nil, + vineal: JSONNull?? = nil + ) -> SisteringClass { + return SisteringClass( + amphicarpic: amphicarpic ?? self.amphicarpic, + chianti: chianti ?? self.chianti, + frigorific: frigorific ?? self.frigorific, + haplomi: haplomi ?? self.haplomi, + hyperkinesis: hyperkinesis ?? self.hyperkinesis, + laudable: laudable ?? self.laudable, + madwoman: madwoman ?? self.madwoman, + maimedly: maimedly ?? self.maimedly, + micropterygidae: micropterygidae ?? self.micropterygidae, + microrhabdus: microrhabdus ?? self.microrhabdus, + nondense: nondense ?? self.nondense, + phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis, + redsear: redsear ?? self.redsear, + schismatical: schismatical ?? self.schismatical, + tartryl: tartryl ?? self.tartryl, + unabhorred: unabhorred ?? self.unabhorred, + undeliberateness: undeliberateness ?? self.undeliberateness, + unmixable: unmixable ?? self.unmixable, + untruckling: untruckling ?? self.untruckling, + vineal: vineal ?? self.vineal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Staghunting +struct Staghunting: Codable, Sendable { + let calorimetric: Int? + let canid: Int? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ditriglyphic: Int? + let floriferousness: Int? + let gamelike: Int? + let grig: Int? + let homocerc: Bool? + let interloan: Int? + let lithotomy: Int? + let loric: Int? + let membranocoriaceous: Int? + let membranogenic: Int? + let nonbookish: JSONNull? + let overtrump: Int? + let scotino: Int? + let seasonable: Int? + let sephen: Int? + let stigmarioid: Int? + let tired: Int? + let trifid: Int? + let undefeatedly: Int? + let ungirlish: Int? + + enum CodingKeys: String, CodingKey { + case calorimetric = "calorimetric" + case canid = "canid" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ditriglyphic = "ditriglyphic" + case floriferousness = "floriferousness" + case gamelike = "gamelike" + case grig = "grig" + case homocerc = "homocerc" + case interloan = "interloan" + case lithotomy = "lithotomy" + case loric = "loric" + case membranocoriaceous = "membranocoriaceous" + case membranogenic = "membranogenic" + case nonbookish = "nonbookish" + case overtrump = "overtrump" + case scotino = "scotino" + case seasonable = "seasonable" + case sephen = "sephen" + case stigmarioid = "stigmarioid" + case tired = "tired" + case trifid = "trifid" + case undefeatedly = "undefeatedly" + case ungirlish = "ungirlish" + } +} + +// MARK: Staghunting convenience initializers and mutators + +extension Staghunting { + init(data: Data) throws { + self = try newJSONDecoder().decode(Staghunting.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + calorimetric: Int?? = nil, + canid: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ditriglyphic: Int?? = nil, + floriferousness: Int?? = nil, + gamelike: Int?? = nil, + grig: Int?? = nil, + homocerc: Bool?? = nil, + interloan: Int?? = nil, + lithotomy: Int?? = nil, + loric: Int?? = nil, + membranocoriaceous: Int?? = nil, + membranogenic: Int?? = nil, + nonbookish: JSONNull?? = nil, + overtrump: Int?? = nil, + scotino: Int?? = nil, + seasonable: Int?? = nil, + sephen: Int?? = nil, + stigmarioid: Int?? = nil, + tired: Int?? = nil, + trifid: Int?? = nil, + undefeatedly: Int?? = nil, + ungirlish: Int?? = nil + ) -> Staghunting { + return Staghunting( + calorimetric: calorimetric ?? self.calorimetric, + canid: canid ?? self.canid, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ditriglyphic: ditriglyphic ?? self.ditriglyphic, + floriferousness: floriferousness ?? self.floriferousness, + gamelike: gamelike ?? self.gamelike, + grig: grig ?? self.grig, + homocerc: homocerc ?? self.homocerc, + interloan: interloan ?? self.interloan, + lithotomy: lithotomy ?? self.lithotomy, + loric: loric ?? self.loric, + membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous, + membranogenic: membranogenic ?? self.membranogenic, + nonbookish: nonbookish ?? self.nonbookish, + overtrump: overtrump ?? self.overtrump, + scotino: scotino ?? self.scotino, + seasonable: seasonable ?? self.seasonable, + sephen: sephen ?? self.sephen, + stigmarioid: stigmarioid ?? self.stigmarioid, + tired: tired ?? self.tired, + trifid: trifid ?? self.trifid, + undefeatedly: undefeatedly ?? self.undefeatedly, + ungirlish: ungirlish ?? self.ungirlish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Stagmometer: Codable, Sendable { + case string(String) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Stimulability: Codable, Sendable { + case bool(Bool) + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Strangleable: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum StrenuosityElement: Codable, Sendable { + case nullArray([JSONNull?]) + case strenuosityClass(StrenuosityClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(StrenuosityClass.self) { + self = .strenuosityClass(x) + return + } + throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .strenuosityClass(let x): + try container.encode(x) + } + } +} + +// MARK: - StrenuosityClass +struct StrenuosityClass: Codable, Sendable { + let bliss: Int? + let buccate: Int? + let bulletproof: Int? + let catharticalness: Double? + let chirotherium: Int? + let crumblingness: Int? + let disdiapason: String? + let engagedly: Int? + let fightable: Int? + let hoariness: Int? + let homocerc: Bool? + let hypopodium: Int? + let luxurist: Int? + let mechanician: Int? + let nonbookish: JSONNull? + let onopordon: Int? + let podgily: Int? + let reformableness: Int? + let scatterbrains: Int? + let seminuria: Int? + let sodomite: Int? + let tramp: Int? + let undueness: Int? + let worthily: Int? + let yankeeist: Int? + + enum CodingKeys: String, CodingKey { + case bliss = "bliss" + case buccate = "buccate" + case bulletproof = "bulletproof" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case crumblingness = "crumblingness" + case disdiapason = "disdiapason" + case engagedly = "engagedly" + case fightable = "fightable" + case hoariness = "hoariness" + case homocerc = "homocerc" + case hypopodium = "hypopodium" + case luxurist = "luxurist" + case mechanician = "mechanician" + case nonbookish = "nonbookish" + case onopordon = "Onopordon" + case podgily = "podgily" + case reformableness = "reformableness" + case scatterbrains = "scatterbrains" + case seminuria = "seminuria" + case sodomite = "Sodomite" + case tramp = "tramp" + case undueness = "undueness" + case worthily = "worthily" + case yankeeist = "Yankeeist" + } +} + +// MARK: StrenuosityClass convenience initializers and mutators + +extension StrenuosityClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(StrenuosityClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bliss: Int?? = nil, + buccate: Int?? = nil, + bulletproof: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + crumblingness: Int?? = nil, + disdiapason: String?? = nil, + engagedly: Int?? = nil, + fightable: Int?? = nil, + hoariness: Int?? = nil, + homocerc: Bool?? = nil, + hypopodium: Int?? = nil, + luxurist: Int?? = nil, + mechanician: Int?? = nil, + nonbookish: JSONNull?? = nil, + onopordon: Int?? = nil, + podgily: Int?? = nil, + reformableness: Int?? = nil, + scatterbrains: Int?? = nil, + seminuria: Int?? = nil, + sodomite: Int?? = nil, + tramp: Int?? = nil, + undueness: Int?? = nil, + worthily: Int?? = nil, + yankeeist: Int?? = nil + ) -> StrenuosityClass { + return StrenuosityClass( + bliss: bliss ?? self.bliss, + buccate: buccate ?? self.buccate, + bulletproof: bulletproof ?? self.bulletproof, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + crumblingness: crumblingness ?? self.crumblingness, + disdiapason: disdiapason ?? self.disdiapason, + engagedly: engagedly ?? self.engagedly, + fightable: fightable ?? self.fightable, + hoariness: hoariness ?? self.hoariness, + homocerc: homocerc ?? self.homocerc, + hypopodium: hypopodium ?? self.hypopodium, + luxurist: luxurist ?? self.luxurist, + mechanician: mechanician ?? self.mechanician, + nonbookish: nonbookish ?? self.nonbookish, + onopordon: onopordon ?? self.onopordon, + podgily: podgily ?? self.podgily, + reformableness: reformableness ?? self.reformableness, + scatterbrains: scatterbrains ?? self.scatterbrains, + seminuria: seminuria ?? self.seminuria, + sodomite: sodomite ?? self.sodomite, + tramp: tramp ?? self.tramp, + undueness: undueness ?? self.undueness, + worthily: worthily ?? self.worthily, + yankeeist: yankeeist ?? self.yankeeist + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Tabaxir: Codable, Sendable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Talpiform: Codable, Sendable { + case double(Double) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Thwack: Codable, Sendable { + case bool(Bool) + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum Tortricine: Codable, Sendable { + case quebrachineClass(QuebrachineClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .quebrachineClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum TruantcyElement: Codable, Sendable { + case bool(Bool) + case truantcyClass(TruantcyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TruantcyClass.self) { + self = .truantcyClass(x) + return + } + throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .truantcyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - TruantcyClass +struct TruantcyClass: Codable, Sendable { + let alfiona: JSONNull? + let ascaridiasis: JSONNull? + let bungey: JSONNull? + let catharticalness: Double? + let ceroxyle: JSONNull? + let chirotherium: Int? + let chorology: JSONNull? + let disdiapason: String? + let enmarble: JSONNull? + let epeira: JSONNull? + let eurylaimi: JSONNull? + let germination: JSONNull? + let hallelujah: JSONNull? + let homocerc: Bool? + let lev: JSONNull? + let mouthing: JSONNull? + let nonbookish: JSONNull? + let philliloo: JSONNull? + let planetal: JSONNull? + let poney: JSONNull? + let punctualist: JSONNull? + let returnlessly: JSONNull? + let skelder: JSONNull? + let windwaywardly: JSONNull? + let yuman: JSONNull? + + enum CodingKeys: String, CodingKey { + case alfiona = "alfiona" + case ascaridiasis = "ascaridiasis" + case bungey = "bungey" + case catharticalness = "catharticalness" + case ceroxyle = "ceroxyle" + case chirotherium = "Chirotherium" + case chorology = "chorology" + case disdiapason = "disdiapason" + case enmarble = "enmarble" + case epeira = "Epeira" + case eurylaimi = "Eurylaimi" + case germination = "germination" + case hallelujah = "hallelujah" + case homocerc = "homocerc" + case lev = "lev" + case mouthing = "mouthing" + case nonbookish = "nonbookish" + case philliloo = "philliloo" + case planetal = "planetal" + case poney = "poney" + case punctualist = "punctualist" + case returnlessly = "returnlessly" + case skelder = "skelder" + case windwaywardly = "windwaywardly" + case yuman = "Yuman" + } +} + +// MARK: TruantcyClass convenience initializers and mutators + +extension TruantcyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(TruantcyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alfiona: JSONNull?? = nil, + ascaridiasis: JSONNull?? = nil, + bungey: JSONNull?? = nil, + catharticalness: Double?? = nil, + ceroxyle: JSONNull?? = nil, + chirotherium: Int?? = nil, + chorology: JSONNull?? = nil, + disdiapason: String?? = nil, + enmarble: JSONNull?? = nil, + epeira: JSONNull?? = nil, + eurylaimi: JSONNull?? = nil, + germination: JSONNull?? = nil, + hallelujah: JSONNull?? = nil, + homocerc: Bool?? = nil, + lev: JSONNull?? = nil, + mouthing: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + philliloo: JSONNull?? = nil, + planetal: JSONNull?? = nil, + poney: JSONNull?? = nil, + punctualist: JSONNull?? = nil, + returnlessly: JSONNull?? = nil, + skelder: JSONNull?? = nil, + windwaywardly: JSONNull?? = nil, + yuman: JSONNull?? = nil + ) -> TruantcyClass { + return TruantcyClass( + alfiona: alfiona ?? self.alfiona, + ascaridiasis: ascaridiasis ?? self.ascaridiasis, + bungey: bungey ?? self.bungey, + catharticalness: catharticalness ?? self.catharticalness, + ceroxyle: ceroxyle ?? self.ceroxyle, + chirotherium: chirotherium ?? self.chirotherium, + chorology: chorology ?? self.chorology, + disdiapason: disdiapason ?? self.disdiapason, + enmarble: enmarble ?? self.enmarble, + epeira: epeira ?? self.epeira, + eurylaimi: eurylaimi ?? self.eurylaimi, + germination: germination ?? self.germination, + hallelujah: hallelujah ?? self.hallelujah, + homocerc: homocerc ?? self.homocerc, + lev: lev ?? self.lev, + mouthing: mouthing ?? self.mouthing, + nonbookish: nonbookish ?? self.nonbookish, + philliloo: philliloo ?? self.philliloo, + planetal: planetal ?? self.planetal, + poney: poney ?? self.poney, + punctualist: punctualist ?? self.punctualist, + returnlessly: returnlessly ?? self.returnlessly, + skelder: skelder ?? self.skelder, + windwaywardly: windwaywardly ?? self.windwaywardly, + yuman: yuman ?? self.yuman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unbeginning: Codable, Sendable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Undesirability: Codable, Sendable { + case integerArray([Int]) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unerasing: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unguentarium: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum UnimpeachablyElement: Codable, Sendable { + case bool(Bool) + case unimpeachablyClass(UnimpeachablyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(UnimpeachablyClass.self) { + self = .unimpeachablyClass(x) + return + } + throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unimpeachablyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - UnimpeachablyClass +struct UnimpeachablyClass: Codable, Sendable { + let acerin: Int? + let bobadil: Int? + let catharticalness: Double? + let chirotherium: Int? + let chlorophylligenous: Int? + let conversational: Int? + let demiowl: Int? + let disdiapason: String? + let ectorhinal: Int? + let gamblesomeness: Int? + let homocerc: Bool? + let irrorate: Int? + let kindergartening: Int? + let lateritic: Int? + let mespil: Int? + let misconfiguration: Int? + let nonbookish: JSONNull? + let planometry: Int? + let quiina: Int? + let robert: Int? + let rot: Int? + let subcinctorium: Int? + let tussocker: Int? + let ultraproud: Int? + let unsuggestedness: Int? + + enum CodingKeys: String, CodingKey { + case acerin = "acerin" + case bobadil = "Bobadil" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorophylligenous = "chlorophylligenous" + case conversational = "conversational" + case demiowl = "demiowl" + case disdiapason = "disdiapason" + case ectorhinal = "ectorhinal" + case gamblesomeness = "gamblesomeness" + case homocerc = "homocerc" + case irrorate = "irrorate" + case kindergartening = "kindergartening" + case lateritic = "lateritic" + case mespil = "mespil" + case misconfiguration = "misconfiguration" + case nonbookish = "nonbookish" + case planometry = "planometry" + case quiina = "Quiina" + case robert = "Robert" + case rot = "rot" + case subcinctorium = "subcinctorium" + case tussocker = "tussocker" + case ultraproud = "ultraproud" + case unsuggestedness = "unsuggestedness" + } +} + +// MARK: UnimpeachablyClass convenience initializers and mutators + +extension UnimpeachablyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acerin: Int?? = nil, + bobadil: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorophylligenous: Int?? = nil, + conversational: Int?? = nil, + demiowl: Int?? = nil, + disdiapason: String?? = nil, + ectorhinal: Int?? = nil, + gamblesomeness: Int?? = nil, + homocerc: Bool?? = nil, + irrorate: Int?? = nil, + kindergartening: Int?? = nil, + lateritic: Int?? = nil, + mespil: Int?? = nil, + misconfiguration: Int?? = nil, + nonbookish: JSONNull?? = nil, + planometry: Int?? = nil, + quiina: Int?? = nil, + robert: Int?? = nil, + rot: Int?? = nil, + subcinctorium: Int?? = nil, + tussocker: Int?? = nil, + ultraproud: Int?? = nil, + unsuggestedness: Int?? = nil + ) -> UnimpeachablyClass { + return UnimpeachablyClass( + acerin: acerin ?? self.acerin, + bobadil: bobadil ?? self.bobadil, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous, + conversational: conversational ?? self.conversational, + demiowl: demiowl ?? self.demiowl, + disdiapason: disdiapason ?? self.disdiapason, + ectorhinal: ectorhinal ?? self.ectorhinal, + gamblesomeness: gamblesomeness ?? self.gamblesomeness, + homocerc: homocerc ?? self.homocerc, + irrorate: irrorate ?? self.irrorate, + kindergartening: kindergartening ?? self.kindergartening, + lateritic: lateritic ?? self.lateritic, + mespil: mespil ?? self.mespil, + misconfiguration: misconfiguration ?? self.misconfiguration, + nonbookish: nonbookish ?? self.nonbookish, + planometry: planometry ?? self.planometry, + quiina: quiina ?? self.quiina, + robert: robert ?? self.robert, + rot: rot ?? self.rot, + subcinctorium: subcinctorium ?? self.subcinctorium, + tussocker: tussocker ?? self.tussocker, + ultraproud: ultraproud ?? self.ultraproud, + unsuggestedness: unsuggestedness ?? self.unsuggestedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unmortgaged: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unobstructed: Codable, Sendable { + case integer(Int) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unreceptivity: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unsatisfactoriness: Codable, Sendable { + case bool(Bool) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum UnstressedElement: Codable, Sendable { + case bool(Bool) + case string(String) + case unstressedClass(UnstressedClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(UnstressedClass.self) { + self = .unstressedClass(x) + return + } + throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .unstressedClass(let x): + try container.encode(x) + } + } +} + +// MARK: - UnstressedClass +struct UnstressedClass: Codable, Sendable { + let alain: JSONNull? + let amphirhina: JSONNull? + let antimachinery: JSONNull? + let coldish: JSONNull? + let crantara: JSONNull? + let distinguishing: JSONNull? + let elytroposis: JSONNull? + let gentianwort: JSONNull? + let heliosis: JSONNull? + let instrumental: JSONNull? + let introinflection: JSONNull? + let kala: JSONNull? + let lincolnian: JSONNull? + let metad: JSONNull? + let sarcophilus: JSONNull? + let swingingly: JSONNull? + let unconformity: JSONNull? + let undecreed: JSONNull? + let venerable: JSONNull? + let vowellessness: JSONNull? + + enum CodingKeys: String, CodingKey { + case alain = "Alain" + case amphirhina = "Amphirhina" + case antimachinery = "antimachinery" + case coldish = "coldish" + case crantara = "crantara" + case distinguishing = "distinguishing" + case elytroposis = "elytroposis" + case gentianwort = "gentianwort" + case heliosis = "heliosis" + case instrumental = "instrumental" + case introinflection = "introinflection" + case kala = "kala" + case lincolnian = "Lincolnian" + case metad = "metad" + case sarcophilus = "Sarcophilus" + case swingingly = "swingingly" + case unconformity = "unconformity" + case undecreed = "undecreed" + case venerable = "venerable" + case vowellessness = "vowellessness" + } +} + +// MARK: UnstressedClass convenience initializers and mutators + +extension UnstressedClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(UnstressedClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alain: JSONNull?? = nil, + amphirhina: JSONNull?? = nil, + antimachinery: JSONNull?? = nil, + coldish: JSONNull?? = nil, + crantara: JSONNull?? = nil, + distinguishing: JSONNull?? = nil, + elytroposis: JSONNull?? = nil, + gentianwort: JSONNull?? = nil, + heliosis: JSONNull?? = nil, + instrumental: JSONNull?? = nil, + introinflection: JSONNull?? = nil, + kala: JSONNull?? = nil, + lincolnian: JSONNull?? = nil, + metad: JSONNull?? = nil, + sarcophilus: JSONNull?? = nil, + swingingly: JSONNull?? = nil, + unconformity: JSONNull?? = nil, + undecreed: JSONNull?? = nil, + venerable: JSONNull?? = nil, + vowellessness: JSONNull?? = nil + ) -> UnstressedClass { + return UnstressedClass( + alain: alain ?? self.alain, + amphirhina: amphirhina ?? self.amphirhina, + antimachinery: antimachinery ?? self.antimachinery, + coldish: coldish ?? self.coldish, + crantara: crantara ?? self.crantara, + distinguishing: distinguishing ?? self.distinguishing, + elytroposis: elytroposis ?? self.elytroposis, + gentianwort: gentianwort ?? self.gentianwort, + heliosis: heliosis ?? self.heliosis, + instrumental: instrumental ?? self.instrumental, + introinflection: introinflection ?? self.introinflection, + kala: kala ?? self.kala, + lincolnian: lincolnian ?? self.lincolnian, + metad: metad ?? self.metad, + sarcophilus: sarcophilus ?? self.sarcophilus, + swingingly: swingingly ?? self.swingingly, + unconformity: unconformity ?? self.unconformity, + undecreed: undecreed ?? self.undecreed, + venerable: venerable ?? self.venerable, + vowellessness: vowellessness ?? self.vowellessness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Untasked: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unvarying: Codable, Sendable { + case bool(Bool) + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Vehemently: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Whitepot: Codable, Sendable { + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum WrothyElement: Codable, Sendable { + case nullArray([JSONNull?]) + case wrothyClass(WrothyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(WrothyClass.self) { + self = .wrothyClass(x) + return + } + throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .wrothyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - WrothyClass +struct WrothyClass: Codable, Sendable { + let aeschynanthus: JSONNull? + let aquiferous: JSONNull? + let cheapener: JSONNull? + let enumeration: JSONNull? + let ephesine: JSONNull? + let escadrille: JSONNull? + let estrous: JSONNull? + let interestedly: JSONNull? + let katakinetomer: JSONNull? + let mortification: JSONNull? + let morula: JSONNull? + let orthosymmetrical: JSONNull? + let overbark: JSONNull? + let politist: JSONNull? + let qualified: JSONNull? + let sphenomalar: JSONNull? + let throatful: JSONNull? + let transhumance: JSONNull? + let triandrian: JSONNull? + let unbooked: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeschynanthus = "Aeschynanthus" + case aquiferous = "aquiferous" + case cheapener = "cheapener" + case enumeration = "enumeration" + case ephesine = "Ephesine" + case escadrille = "escadrille" + case estrous = "estrous" + case interestedly = "interestedly" + case katakinetomer = "katakinetomer" + case mortification = "mortification" + case morula = "morula" + case orthosymmetrical = "orthosymmetrical" + case overbark = "overbark" + case politist = "politist" + case qualified = "qualified" + case sphenomalar = "sphenomalar" + case throatful = "throatful" + case transhumance = "transhumance" + case triandrian = "triandrian" + case unbooked = "unbooked" + } +} + +// MARK: WrothyClass convenience initializers and mutators + +extension WrothyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(WrothyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeschynanthus: JSONNull?? = nil, + aquiferous: JSONNull?? = nil, + cheapener: JSONNull?? = nil, + enumeration: JSONNull?? = nil, + ephesine: JSONNull?? = nil, + escadrille: JSONNull?? = nil, + estrous: JSONNull?? = nil, + interestedly: JSONNull?? = nil, + katakinetomer: JSONNull?? = nil, + mortification: JSONNull?? = nil, + morula: JSONNull?? = nil, + orthosymmetrical: JSONNull?? = nil, + overbark: JSONNull?? = nil, + politist: JSONNull?? = nil, + qualified: JSONNull?? = nil, + sphenomalar: JSONNull?? = nil, + throatful: JSONNull?? = nil, + transhumance: JSONNull?? = nil, + triandrian: JSONNull?? = nil, + unbooked: JSONNull?? = nil + ) -> WrothyClass { + return WrothyClass( + aeschynanthus: aeschynanthus ?? self.aeschynanthus, + aquiferous: aquiferous ?? self.aquiferous, + cheapener: cheapener ?? self.cheapener, + enumeration: enumeration ?? self.enumeration, + ephesine: ephesine ?? self.ephesine, + escadrille: escadrille ?? self.escadrille, + estrous: estrous ?? self.estrous, + interestedly: interestedly ?? self.interestedly, + katakinetomer: katakinetomer ?? self.katakinetomer, + mortification: mortification ?? self.mortification, + morula: morula ?? self.morula, + orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical, + overbark: overbark ?? self.overbark, + politist: politist ?? self.politist, + qualified: qualified ?? self.qualified, + sphenomalar: sphenomalar ?? self.sphenomalar, + throatful: throatful ?? self.throatful, + transhumance: transhumance ?? self.transhumance, + triandrian: triandrian ?? self.triandrian, + unbooked: unbooked ?? self.unbooked + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable/test/inputs/json/priority/combinations4.json/struct-or-class-class--238d6c8a12d4/quicktype.swift b/head/swift-sendable/test/inputs/json/priority/combinations4.json/struct-or-class-class--238d6c8a12d4/quicktype.swift new file mode 100644 index 0000000..eb336e8 --- /dev/null +++ b/head/swift-sendable/test/inputs/json/priority/combinations4.json/struct-or-class-class--238d6c8a12d4/quicktype.swift @@ -0,0 +1,4096 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable, Sendable { + let protrusive: [Protrusive] + let pulpitism: [PulpitismElement] + let pyodermia: [PyodermiaElement] + let quebrachine: [QuebrachineElement] + let querier: [Querier] + let rebarbative: [Rebarbative] + let reimagine: [Reimagine] + let ressaut: Ressaut + let retrocervical: [Retrocervical] + let revert: [Revert] + let rewrite: [RewriteElement] + let saccoderm: [Saccoderm] + let santir: [SantirElement] + let saprophilous: [Saprophilous] + let saxten: [SaxtenElement] + let scatty: [Scatty?] + let scoffer: [Scoffer] + let scrampum: [Scrampum] + let semantic: Double + let serpentinic: [Serpentinic] + let shadowable: [Shadowable] + let sistering: [SisteringElement] + let staghunting: [Staghunting] + let stagmometer: [Stagmometer] + let stimulability: [Stimulability] + let strangleable: [Strangleable] + let strenuosity: [StrenuosityElement] + let tabaxir: [Tabaxir] + let talpiform: [Talpiform] + let thwack: [Thwack] + let to: [Double?] + let tortricine: [Tortricine] + let truantcy: [TruantcyElement] + let turgesce: [String] + let unbeginning: [Unbeginning] + let underdunged: [Double] + let undesirability: [Undesirability] + let unerasing: [Unerasing] + let unguentarium: [Unguentarium] + let unimpeachably: [UnimpeachablyElement] + let unmortgaged: [Unmortgaged] + let unobstructed: [Unobstructed] + let unreceptivity: [Unreceptivity] + let unsatisfactoriness: [Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [UnstressedElement] + let untasked: [Untasked] + let unvarying: [Unvarying] + let vehemently: [Vehemently] + let warriorship: [String: Bool] + let whitepot: [Whitepot] + let wrothy: [WrothyElement] + + enum CodingKeys: String, CodingKey { + case protrusive = "protrusive" + case pulpitism = "pulpitism" + case pyodermia = "pyodermia" + case quebrachine = "quebrachine" + case querier = "querier" + case rebarbative = "rebarbative" + case reimagine = "reimagine" + case ressaut = "ressaut" + case retrocervical = "retrocervical" + case revert = "revert" + case rewrite = "rewrite" + case saccoderm = "saccoderm" + case santir = "santir" + case saprophilous = "saprophilous" + case saxten = "saxten" + case scatty = "scatty" + case scoffer = "scoffer" + case scrampum = "scrampum" + case semantic = "semantic" + case serpentinic = "serpentinic" + case shadowable = "shadowable" + case sistering = "sistering" + case staghunting = "staghunting" + case stagmometer = "stagmometer" + case stimulability = "stimulability" + case strangleable = "strangleable" + case strenuosity = "strenuosity" + case tabaxir = "tabaxir" + case talpiform = "talpiform" + case thwack = "thwack" + case to = "to" + case tortricine = "tortricine" + case truantcy = "truantcy" + case turgesce = "turgesce" + case unbeginning = "unbeginning" + case underdunged = "underdunged" + case undesirability = "undesirability" + case unerasing = "unerasing" + case unguentarium = "unguentarium" + case unimpeachably = "unimpeachably" + case unmortgaged = "unmortgaged" + case unobstructed = "unobstructed" + case unreceptivity = "unreceptivity" + case unsatisfactoriness = "unsatisfactoriness" + case unsecurity = "unsecurity" + case unstressed = "unstressed" + case untasked = "untasked" + case unvarying = "unvarying" + case vehemently = "vehemently" + case warriorship = "warriorship" + case whitepot = "whitepot" + case wrothy = "wrothy" + } + + init(protrusive: [Protrusive], pulpitism: [PulpitismElement], pyodermia: [PyodermiaElement], quebrachine: [QuebrachineElement], querier: [Querier], rebarbative: [Rebarbative], reimagine: [Reimagine], ressaut: Ressaut, retrocervical: [Retrocervical], revert: [Revert], rewrite: [RewriteElement], saccoderm: [Saccoderm], santir: [SantirElement], saprophilous: [Saprophilous], saxten: [SaxtenElement], scatty: [Scatty?], scoffer: [Scoffer], scrampum: [Scrampum], semantic: Double, serpentinic: [Serpentinic], shadowable: [Shadowable], sistering: [SisteringElement], staghunting: [Staghunting], stagmometer: [Stagmometer], stimulability: [Stimulability], strangleable: [Strangleable], strenuosity: [StrenuosityElement], tabaxir: [Tabaxir], talpiform: [Talpiform], thwack: [Thwack], to: [Double?], tortricine: [Tortricine], truantcy: [TruantcyElement], turgesce: [String], unbeginning: [Unbeginning], underdunged: [Double], undesirability: [Undesirability], unerasing: [Unerasing], unguentarium: [Unguentarium], unimpeachably: [UnimpeachablyElement], unmortgaged: [Unmortgaged], unobstructed: [Unobstructed], unreceptivity: [Unreceptivity], unsatisfactoriness: [Unsatisfactoriness], unsecurity: [Int], unstressed: [UnstressedElement], untasked: [Untasked], unvarying: [Unvarying], vehemently: [Vehemently], warriorship: [String: Bool], whitepot: [Whitepot], wrothy: [WrothyElement]) { + self.protrusive = protrusive + self.pulpitism = pulpitism + self.pyodermia = pyodermia + self.quebrachine = quebrachine + self.querier = querier + self.rebarbative = rebarbative + self.reimagine = reimagine + self.ressaut = ressaut + self.retrocervical = retrocervical + self.revert = revert + self.rewrite = rewrite + self.saccoderm = saccoderm + self.santir = santir + self.saprophilous = saprophilous + self.saxten = saxten + self.scatty = scatty + self.scoffer = scoffer + self.scrampum = scrampum + self.semantic = semantic + self.serpentinic = serpentinic + self.shadowable = shadowable + self.sistering = sistering + self.staghunting = staghunting + self.stagmometer = stagmometer + self.stimulability = stimulability + self.strangleable = strangleable + self.strenuosity = strenuosity + self.tabaxir = tabaxir + self.talpiform = talpiform + self.thwack = thwack + self.to = to + self.tortricine = tortricine + self.truantcy = truantcy + self.turgesce = turgesce + self.unbeginning = unbeginning + self.underdunged = underdunged + self.undesirability = undesirability + self.unerasing = unerasing + self.unguentarium = unguentarium + self.unimpeachably = unimpeachably + self.unmortgaged = unmortgaged + self.unobstructed = unobstructed + self.unreceptivity = unreceptivity + self.unsatisfactoriness = unsatisfactoriness + self.unsecurity = unsecurity + self.unstressed = unstressed + self.untasked = untasked + self.unvarying = unvarying + self.vehemently = vehemently + self.warriorship = warriorship + self.whitepot = whitepot + self.wrothy = wrothy + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(protrusive: me.protrusive, pulpitism: me.pulpitism, pyodermia: me.pyodermia, quebrachine: me.quebrachine, querier: me.querier, rebarbative: me.rebarbative, reimagine: me.reimagine, ressaut: me.ressaut, retrocervical: me.retrocervical, revert: me.revert, rewrite: me.rewrite, saccoderm: me.saccoderm, santir: me.santir, saprophilous: me.saprophilous, saxten: me.saxten, scatty: me.scatty, scoffer: me.scoffer, scrampum: me.scrampum, semantic: me.semantic, serpentinic: me.serpentinic, shadowable: me.shadowable, sistering: me.sistering, staghunting: me.staghunting, stagmometer: me.stagmometer, stimulability: me.stimulability, strangleable: me.strangleable, strenuosity: me.strenuosity, tabaxir: me.tabaxir, talpiform: me.talpiform, thwack: me.thwack, to: me.to, tortricine: me.tortricine, truantcy: me.truantcy, turgesce: me.turgesce, unbeginning: me.unbeginning, underdunged: me.underdunged, undesirability: me.undesirability, unerasing: me.unerasing, unguentarium: me.unguentarium, unimpeachably: me.unimpeachably, unmortgaged: me.unmortgaged, unobstructed: me.unobstructed, unreceptivity: me.unreceptivity, unsatisfactoriness: me.unsatisfactoriness, unsecurity: me.unsecurity, unstressed: me.unstressed, untasked: me.untasked, unvarying: me.unvarying, vehemently: me.vehemently, warriorship: me.warriorship, whitepot: me.whitepot, wrothy: me.wrothy) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + protrusive: [Protrusive]? = nil, + pulpitism: [PulpitismElement]? = nil, + pyodermia: [PyodermiaElement]? = nil, + quebrachine: [QuebrachineElement]? = nil, + querier: [Querier]? = nil, + rebarbative: [Rebarbative]? = nil, + reimagine: [Reimagine]? = nil, + ressaut: Ressaut? = nil, + retrocervical: [Retrocervical]? = nil, + revert: [Revert]? = nil, + rewrite: [RewriteElement]? = nil, + saccoderm: [Saccoderm]? = nil, + santir: [SantirElement]? = nil, + saprophilous: [Saprophilous]? = nil, + saxten: [SaxtenElement]? = nil, + scatty: [Scatty?]? = nil, + scoffer: [Scoffer]? = nil, + scrampum: [Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [Serpentinic]? = nil, + shadowable: [Shadowable]? = nil, + sistering: [SisteringElement]? = nil, + staghunting: [Staghunting]? = nil, + stagmometer: [Stagmometer]? = nil, + stimulability: [Stimulability]? = nil, + strangleable: [Strangleable]? = nil, + strenuosity: [StrenuosityElement]? = nil, + tabaxir: [Tabaxir]? = nil, + talpiform: [Talpiform]? = nil, + thwack: [Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [Tortricine]? = nil, + truantcy: [TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [Undesirability]? = nil, + unerasing: [Unerasing]? = nil, + unguentarium: [Unguentarium]? = nil, + unimpeachably: [UnimpeachablyElement]? = nil, + unmortgaged: [Unmortgaged]? = nil, + unobstructed: [Unobstructed]? = nil, + unreceptivity: [Unreceptivity]? = nil, + unsatisfactoriness: [Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [UnstressedElement]? = nil, + untasked: [Untasked]? = nil, + unvarying: [Unvarying]? = nil, + vehemently: [Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [Whitepot]? = nil, + wrothy: [WrothyElement]? = nil + ) -> TopLevel { + return TopLevel( + protrusive: protrusive ?? self.protrusive, + pulpitism: pulpitism ?? self.pulpitism, + pyodermia: pyodermia ?? self.pyodermia, + quebrachine: quebrachine ?? self.quebrachine, + querier: querier ?? self.querier, + rebarbative: rebarbative ?? self.rebarbative, + reimagine: reimagine ?? self.reimagine, + ressaut: ressaut ?? self.ressaut, + retrocervical: retrocervical ?? self.retrocervical, + revert: revert ?? self.revert, + rewrite: rewrite ?? self.rewrite, + saccoderm: saccoderm ?? self.saccoderm, + santir: santir ?? self.santir, + saprophilous: saprophilous ?? self.saprophilous, + saxten: saxten ?? self.saxten, + scatty: scatty ?? self.scatty, + scoffer: scoffer ?? self.scoffer, + scrampum: scrampum ?? self.scrampum, + semantic: semantic ?? self.semantic, + serpentinic: serpentinic ?? self.serpentinic, + shadowable: shadowable ?? self.shadowable, + sistering: sistering ?? self.sistering, + staghunting: staghunting ?? self.staghunting, + stagmometer: stagmometer ?? self.stagmometer, + stimulability: stimulability ?? self.stimulability, + strangleable: strangleable ?? self.strangleable, + strenuosity: strenuosity ?? self.strenuosity, + tabaxir: tabaxir ?? self.tabaxir, + talpiform: talpiform ?? self.talpiform, + thwack: thwack ?? self.thwack, + to: to ?? self.to, + tortricine: tortricine ?? self.tortricine, + truantcy: truantcy ?? self.truantcy, + turgesce: turgesce ?? self.turgesce, + unbeginning: unbeginning ?? self.unbeginning, + underdunged: underdunged ?? self.underdunged, + undesirability: undesirability ?? self.undesirability, + unerasing: unerasing ?? self.unerasing, + unguentarium: unguentarium ?? self.unguentarium, + unimpeachably: unimpeachably ?? self.unimpeachably, + unmortgaged: unmortgaged ?? self.unmortgaged, + unobstructed: unobstructed ?? self.unobstructed, + unreceptivity: unreceptivity ?? self.unreceptivity, + unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness, + unsecurity: unsecurity ?? self.unsecurity, + unstressed: unstressed ?? self.unstressed, + untasked: untasked ?? self.untasked, + unvarying: unvarying ?? self.unvarying, + vehemently: vehemently ?? self.vehemently, + warriorship: warriorship ?? self.warriorship, + whitepot: whitepot ?? self.whitepot, + wrothy: wrothy ?? self.wrothy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Protrusive: Codable, Sendable { + case double(Double) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum PulpitismElement: Codable, Sendable { + case double(Double) + case integerArray([Int]) + case pulpitismClass(PulpitismClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PulpitismClass.self) { + self = .pulpitismClass(x) + return + } + throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .pulpitismClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PulpitismClass +final class PulpitismClass: Codable, Sendable { + let abnet: JSONNull? + let buckhorn: JSONNull? + let calciform: JSONNull? + let chelophore: JSONNull? + let cogitation: JSONNull? + let decreeable: JSONNull? + let despicable: JSONNull? + let isodiazo: JSONNull? + let jadedly: JSONNull? + let leptochlorite: JSONNull? + let nursling: JSONNull? + let palamedean: JSONNull? + let photoheliograph: JSONNull? + let pipewood: JSONNull? + let roberd: JSONNull? + let statable: JSONNull? + let superassume: JSONNull? + let syllabe: JSONNull? + let toughhead: JSONNull? + let underburn: JSONNull? + + enum CodingKeys: String, CodingKey { + case abnet = "abnet" + case buckhorn = "buckhorn" + case calciform = "calciform" + case chelophore = "chelophore" + case cogitation = "cogitation" + case decreeable = "decreeable" + case despicable = "despicable" + case isodiazo = "isodiazo" + case jadedly = "jadedly" + case leptochlorite = "leptochlorite" + case nursling = "nursling" + case palamedean = "palamedean" + case photoheliograph = "photoheliograph" + case pipewood = "pipewood" + case roberd = "roberd" + case statable = "statable" + case superassume = "superassume" + case syllabe = "syllabe" + case toughhead = "toughhead" + case underburn = "underburn" + } + + init(abnet: JSONNull?, buckhorn: JSONNull?, calciform: JSONNull?, chelophore: JSONNull?, cogitation: JSONNull?, decreeable: JSONNull?, despicable: JSONNull?, isodiazo: JSONNull?, jadedly: JSONNull?, leptochlorite: JSONNull?, nursling: JSONNull?, palamedean: JSONNull?, photoheliograph: JSONNull?, pipewood: JSONNull?, roberd: JSONNull?, statable: JSONNull?, superassume: JSONNull?, syllabe: JSONNull?, toughhead: JSONNull?, underburn: JSONNull?) { + self.abnet = abnet + self.buckhorn = buckhorn + self.calciform = calciform + self.chelophore = chelophore + self.cogitation = cogitation + self.decreeable = decreeable + self.despicable = despicable + self.isodiazo = isodiazo + self.jadedly = jadedly + self.leptochlorite = leptochlorite + self.nursling = nursling + self.palamedean = palamedean + self.photoheliograph = photoheliograph + self.pipewood = pipewood + self.roberd = roberd + self.statable = statable + self.superassume = superassume + self.syllabe = syllabe + self.toughhead = toughhead + self.underburn = underburn + } +} + +// MARK: PulpitismClass convenience initializers and mutators + +extension PulpitismClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PulpitismClass.self, from: data) + self.init(abnet: me.abnet, buckhorn: me.buckhorn, calciform: me.calciform, chelophore: me.chelophore, cogitation: me.cogitation, decreeable: me.decreeable, despicable: me.despicable, isodiazo: me.isodiazo, jadedly: me.jadedly, leptochlorite: me.leptochlorite, nursling: me.nursling, palamedean: me.palamedean, photoheliograph: me.photoheliograph, pipewood: me.pipewood, roberd: me.roberd, statable: me.statable, superassume: me.superassume, syllabe: me.syllabe, toughhead: me.toughhead, underburn: me.underburn) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abnet: JSONNull?? = nil, + buckhorn: JSONNull?? = nil, + calciform: JSONNull?? = nil, + chelophore: JSONNull?? = nil, + cogitation: JSONNull?? = nil, + decreeable: JSONNull?? = nil, + despicable: JSONNull?? = nil, + isodiazo: JSONNull?? = nil, + jadedly: JSONNull?? = nil, + leptochlorite: JSONNull?? = nil, + nursling: JSONNull?? = nil, + palamedean: JSONNull?? = nil, + photoheliograph: JSONNull?? = nil, + pipewood: JSONNull?? = nil, + roberd: JSONNull?? = nil, + statable: JSONNull?? = nil, + superassume: JSONNull?? = nil, + syllabe: JSONNull?? = nil, + toughhead: JSONNull?? = nil, + underburn: JSONNull?? = nil + ) -> PulpitismClass { + return PulpitismClass( + abnet: abnet ?? self.abnet, + buckhorn: buckhorn ?? self.buckhorn, + calciform: calciform ?? self.calciform, + chelophore: chelophore ?? self.chelophore, + cogitation: cogitation ?? self.cogitation, + decreeable: decreeable ?? self.decreeable, + despicable: despicable ?? self.despicable, + isodiazo: isodiazo ?? self.isodiazo, + jadedly: jadedly ?? self.jadedly, + leptochlorite: leptochlorite ?? self.leptochlorite, + nursling: nursling ?? self.nursling, + palamedean: palamedean ?? self.palamedean, + photoheliograph: photoheliograph ?? self.photoheliograph, + pipewood: pipewood ?? self.pipewood, + roberd: roberd ?? self.roberd, + statable: statable ?? self.statable, + superassume: superassume ?? self.superassume, + syllabe: syllabe ?? self.syllabe, + toughhead: toughhead ?? self.toughhead, + underburn: underburn ?? self.underburn + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum PyodermiaElement: Codable, Sendable { + case integer(Int) + case pyodermiaClass(PyodermiaClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PyodermiaClass.self) { + self = .pyodermiaClass(x) + return + } + throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .pyodermiaClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PyodermiaClass +final class PyodermiaClass: Codable, Sendable { + let aphoristically: JSONNull? + let apophyllous: JSONNull? + let cognize: JSONNull? + let dermonosology: JSONNull? + let gyppo: JSONNull? + let ither: JSONNull? + let juglandaceous: JSONNull? + let litho: JSONNull? + let macropterous: JSONNull? + let photographer: JSONNull? + let romancing: JSONNull? + let rumness: JSONNull? + let somniloquist: JSONNull? + let stressfully: JSONNull? + let tactically: JSONNull? + let tracheophony: JSONNull? + let unappositely: JSONNull? + let unclothedly: JSONNull? + let unimplied: JSONNull? + let unsyncopated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aphoristically = "aphoristically" + case apophyllous = "apophyllous" + case cognize = "cognize" + case dermonosology = "dermonosology" + case gyppo = "Gyppo" + case ither = "ither" + case juglandaceous = "juglandaceous" + case litho = "litho" + case macropterous = "macropterous" + case photographer = "photographer" + case romancing = "romancing" + case rumness = "rumness" + case somniloquist = "somniloquist" + case stressfully = "stressfully" + case tactically = "tactically" + case tracheophony = "tracheophony" + case unappositely = "unappositely" + case unclothedly = "unclothedly" + case unimplied = "unimplied" + case unsyncopated = "unsyncopated" + } + + init(aphoristically: JSONNull?, apophyllous: JSONNull?, cognize: JSONNull?, dermonosology: JSONNull?, gyppo: JSONNull?, ither: JSONNull?, juglandaceous: JSONNull?, litho: JSONNull?, macropterous: JSONNull?, photographer: JSONNull?, romancing: JSONNull?, rumness: JSONNull?, somniloquist: JSONNull?, stressfully: JSONNull?, tactically: JSONNull?, tracheophony: JSONNull?, unappositely: JSONNull?, unclothedly: JSONNull?, unimplied: JSONNull?, unsyncopated: JSONNull?) { + self.aphoristically = aphoristically + self.apophyllous = apophyllous + self.cognize = cognize + self.dermonosology = dermonosology + self.gyppo = gyppo + self.ither = ither + self.juglandaceous = juglandaceous + self.litho = litho + self.macropterous = macropterous + self.photographer = photographer + self.romancing = romancing + self.rumness = rumness + self.somniloquist = somniloquist + self.stressfully = stressfully + self.tactically = tactically + self.tracheophony = tracheophony + self.unappositely = unappositely + self.unclothedly = unclothedly + self.unimplied = unimplied + self.unsyncopated = unsyncopated + } +} + +// MARK: PyodermiaClass convenience initializers and mutators + +extension PyodermiaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PyodermiaClass.self, from: data) + self.init(aphoristically: me.aphoristically, apophyllous: me.apophyllous, cognize: me.cognize, dermonosology: me.dermonosology, gyppo: me.gyppo, ither: me.ither, juglandaceous: me.juglandaceous, litho: me.litho, macropterous: me.macropterous, photographer: me.photographer, romancing: me.romancing, rumness: me.rumness, somniloquist: me.somniloquist, stressfully: me.stressfully, tactically: me.tactically, tracheophony: me.tracheophony, unappositely: me.unappositely, unclothedly: me.unclothedly, unimplied: me.unimplied, unsyncopated: me.unsyncopated) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aphoristically: JSONNull?? = nil, + apophyllous: JSONNull?? = nil, + cognize: JSONNull?? = nil, + dermonosology: JSONNull?? = nil, + gyppo: JSONNull?? = nil, + ither: JSONNull?? = nil, + juglandaceous: JSONNull?? = nil, + litho: JSONNull?? = nil, + macropterous: JSONNull?? = nil, + photographer: JSONNull?? = nil, + romancing: JSONNull?? = nil, + rumness: JSONNull?? = nil, + somniloquist: JSONNull?? = nil, + stressfully: JSONNull?? = nil, + tactically: JSONNull?? = nil, + tracheophony: JSONNull?? = nil, + unappositely: JSONNull?? = nil, + unclothedly: JSONNull?? = nil, + unimplied: JSONNull?? = nil, + unsyncopated: JSONNull?? = nil + ) -> PyodermiaClass { + return PyodermiaClass( + aphoristically: aphoristically ?? self.aphoristically, + apophyllous: apophyllous ?? self.apophyllous, + cognize: cognize ?? self.cognize, + dermonosology: dermonosology ?? self.dermonosology, + gyppo: gyppo ?? self.gyppo, + ither: ither ?? self.ither, + juglandaceous: juglandaceous ?? self.juglandaceous, + litho: litho ?? self.litho, + macropterous: macropterous ?? self.macropterous, + photographer: photographer ?? self.photographer, + romancing: romancing ?? self.romancing, + rumness: rumness ?? self.rumness, + somniloquist: somniloquist ?? self.somniloquist, + stressfully: stressfully ?? self.stressfully, + tactically: tactically ?? self.tactically, + tracheophony: tracheophony ?? self.tracheophony, + unappositely: unappositely ?? self.unappositely, + unclothedly: unclothedly ?? self.unclothedly, + unimplied: unimplied ?? self.unimplied, + unsyncopated: unsyncopated ?? self.unsyncopated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum QuebrachineElement: Codable, Sendable { + case bool(Bool) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - QuebrachineClass +final class QuebrachineClass: Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: QuebrachineClass convenience initializers and mutators + +extension QuebrachineClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(QuebrachineClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> QuebrachineClass { + return QuebrachineClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Querier: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Rebarbative: Codable, Sendable { + case bool(Bool) + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - Reimagine +final class Reimagine: Codable, Sendable { + let adducible: JSONNull? + let anabolin: JSONNull? + let brainy: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let chrysamine: JSONNull? + let disdiapason: String? + let fluxweed: JSONNull? + let glaucine: JSONNull? + let grobianism: JSONNull? + let hermo: JSONNull? + let hieroglyphist: JSONNull? + let homocerc: Bool? + let icteroid: JSONNull? + let immortal: JSONNull? + let impetulant: JSONNull? + let irrigate: JSONNull? + let myxedema: JSONNull? + let nonbookish: JSONNull? + let onyx: JSONNull? + let repasser: JSONNull? + let septomarginal: JSONNull? + let subdie: JSONNull? + let tibiometatarsal: JSONNull? + let waltzlike: JSONNull? + + enum CodingKeys: String, CodingKey { + case adducible = "adducible" + case anabolin = "anabolin" + case brainy = "brainy" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chrysamine = "chrysamine" + case disdiapason = "disdiapason" + case fluxweed = "fluxweed" + case glaucine = "glaucine" + case grobianism = "grobianism" + case hermo = "Hermo" + case hieroglyphist = "hieroglyphist" + case homocerc = "homocerc" + case icteroid = "icteroid" + case immortal = "immortal" + case impetulant = "impetulant" + case irrigate = "irrigate" + case myxedema = "myxedema" + case nonbookish = "nonbookish" + case onyx = "onyx" + case repasser = "repasser" + case septomarginal = "septomarginal" + case subdie = "subdie" + case tibiometatarsal = "tibiometatarsal" + case waltzlike = "waltzlike" + } + + init(adducible: JSONNull?, anabolin: JSONNull?, brainy: JSONNull?, catharticalness: Double?, chirotherium: Int?, chrysamine: JSONNull?, disdiapason: String?, fluxweed: JSONNull?, glaucine: JSONNull?, grobianism: JSONNull?, hermo: JSONNull?, hieroglyphist: JSONNull?, homocerc: Bool?, icteroid: JSONNull?, immortal: JSONNull?, impetulant: JSONNull?, irrigate: JSONNull?, myxedema: JSONNull?, nonbookish: JSONNull?, onyx: JSONNull?, repasser: JSONNull?, septomarginal: JSONNull?, subdie: JSONNull?, tibiometatarsal: JSONNull?, waltzlike: JSONNull?) { + self.adducible = adducible + self.anabolin = anabolin + self.brainy = brainy + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chrysamine = chrysamine + self.disdiapason = disdiapason + self.fluxweed = fluxweed + self.glaucine = glaucine + self.grobianism = grobianism + self.hermo = hermo + self.hieroglyphist = hieroglyphist + self.homocerc = homocerc + self.icteroid = icteroid + self.immortal = immortal + self.impetulant = impetulant + self.irrigate = irrigate + self.myxedema = myxedema + self.nonbookish = nonbookish + self.onyx = onyx + self.repasser = repasser + self.septomarginal = septomarginal + self.subdie = subdie + self.tibiometatarsal = tibiometatarsal + self.waltzlike = waltzlike + } +} + +// MARK: Reimagine convenience initializers and mutators + +extension Reimagine { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Reimagine.self, from: data) + self.init(adducible: me.adducible, anabolin: me.anabolin, brainy: me.brainy, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chrysamine: me.chrysamine, disdiapason: me.disdiapason, fluxweed: me.fluxweed, glaucine: me.glaucine, grobianism: me.grobianism, hermo: me.hermo, hieroglyphist: me.hieroglyphist, homocerc: me.homocerc, icteroid: me.icteroid, immortal: me.immortal, impetulant: me.impetulant, irrigate: me.irrigate, myxedema: me.myxedema, nonbookish: me.nonbookish, onyx: me.onyx, repasser: me.repasser, septomarginal: me.septomarginal, subdie: me.subdie, tibiometatarsal: me.tibiometatarsal, waltzlike: me.waltzlike) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adducible: JSONNull?? = nil, + anabolin: JSONNull?? = nil, + brainy: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chrysamine: JSONNull?? = nil, + disdiapason: String?? = nil, + fluxweed: JSONNull?? = nil, + glaucine: JSONNull?? = nil, + grobianism: JSONNull?? = nil, + hermo: JSONNull?? = nil, + hieroglyphist: JSONNull?? = nil, + homocerc: Bool?? = nil, + icteroid: JSONNull?? = nil, + immortal: JSONNull?? = nil, + impetulant: JSONNull?? = nil, + irrigate: JSONNull?? = nil, + myxedema: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + onyx: JSONNull?? = nil, + repasser: JSONNull?? = nil, + septomarginal: JSONNull?? = nil, + subdie: JSONNull?? = nil, + tibiometatarsal: JSONNull?? = nil, + waltzlike: JSONNull?? = nil + ) -> Reimagine { + return Reimagine( + adducible: adducible ?? self.adducible, + anabolin: anabolin ?? self.anabolin, + brainy: brainy ?? self.brainy, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chrysamine: chrysamine ?? self.chrysamine, + disdiapason: disdiapason ?? self.disdiapason, + fluxweed: fluxweed ?? self.fluxweed, + glaucine: glaucine ?? self.glaucine, + grobianism: grobianism ?? self.grobianism, + hermo: hermo ?? self.hermo, + hieroglyphist: hieroglyphist ?? self.hieroglyphist, + homocerc: homocerc ?? self.homocerc, + icteroid: icteroid ?? self.icteroid, + immortal: immortal ?? self.immortal, + impetulant: impetulant ?? self.impetulant, + irrigate: irrigate ?? self.irrigate, + myxedema: myxedema ?? self.myxedema, + nonbookish: nonbookish ?? self.nonbookish, + onyx: onyx ?? self.onyx, + repasser: repasser ?? self.repasser, + septomarginal: septomarginal ?? self.septomarginal, + subdie: subdie ?? self.subdie, + tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal, + waltzlike: waltzlike ?? self.waltzlike + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Ressaut +final class Ressaut: Codable, Sendable { + let apperceptive: String + let cuttoo: String + let douser: String + let drinkproof: String + let forementioned: String + let freesia: String + let genevieve: String + let hyperdiabolical: String + let hypocone: String + let irreverentially: String + let jumart: String + let mimosaceae: String + let mollicrush: String + let nedder: String + let retinasphalt: String + let sough: String + let steading: String + let theopaschitism: String + let undurableness: String + let unmingleable: String + + enum CodingKeys: String, CodingKey { + case apperceptive = "apperceptive" + case cuttoo = "cuttoo" + case douser = "douser" + case drinkproof = "drinkproof" + case forementioned = "forementioned" + case freesia = "Freesia" + case genevieve = "Genevieve" + case hyperdiabolical = "hyperdiabolical" + case hypocone = "hypocone" + case irreverentially = "irreverentially" + case jumart = "jumart" + case mimosaceae = "Mimosaceae" + case mollicrush = "mollicrush" + case nedder = "nedder" + case retinasphalt = "retinasphalt" + case sough = "sough" + case steading = "steading" + case theopaschitism = "Theopaschitism" + case undurableness = "undurableness" + case unmingleable = "unmingleable" + } + + init(apperceptive: String, cuttoo: String, douser: String, drinkproof: String, forementioned: String, freesia: String, genevieve: String, hyperdiabolical: String, hypocone: String, irreverentially: String, jumart: String, mimosaceae: String, mollicrush: String, nedder: String, retinasphalt: String, sough: String, steading: String, theopaschitism: String, undurableness: String, unmingleable: String) { + self.apperceptive = apperceptive + self.cuttoo = cuttoo + self.douser = douser + self.drinkproof = drinkproof + self.forementioned = forementioned + self.freesia = freesia + self.genevieve = genevieve + self.hyperdiabolical = hyperdiabolical + self.hypocone = hypocone + self.irreverentially = irreverentially + self.jumart = jumart + self.mimosaceae = mimosaceae + self.mollicrush = mollicrush + self.nedder = nedder + self.retinasphalt = retinasphalt + self.sough = sough + self.steading = steading + self.theopaschitism = theopaschitism + self.undurableness = undurableness + self.unmingleable = unmingleable + } +} + +// MARK: Ressaut convenience initializers and mutators + +extension Ressaut { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Ressaut.self, from: data) + self.init(apperceptive: me.apperceptive, cuttoo: me.cuttoo, douser: me.douser, drinkproof: me.drinkproof, forementioned: me.forementioned, freesia: me.freesia, genevieve: me.genevieve, hyperdiabolical: me.hyperdiabolical, hypocone: me.hypocone, irreverentially: me.irreverentially, jumart: me.jumart, mimosaceae: me.mimosaceae, mollicrush: me.mollicrush, nedder: me.nedder, retinasphalt: me.retinasphalt, sough: me.sough, steading: me.steading, theopaschitism: me.theopaschitism, undurableness: me.undurableness, unmingleable: me.unmingleable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apperceptive: String? = nil, + cuttoo: String? = nil, + douser: String? = nil, + drinkproof: String? = nil, + forementioned: String? = nil, + freesia: String? = nil, + genevieve: String? = nil, + hyperdiabolical: String? = nil, + hypocone: String? = nil, + irreverentially: String? = nil, + jumart: String? = nil, + mimosaceae: String? = nil, + mollicrush: String? = nil, + nedder: String? = nil, + retinasphalt: String? = nil, + sough: String? = nil, + steading: String? = nil, + theopaschitism: String? = nil, + undurableness: String? = nil, + unmingleable: String? = nil + ) -> Ressaut { + return Ressaut( + apperceptive: apperceptive ?? self.apperceptive, + cuttoo: cuttoo ?? self.cuttoo, + douser: douser ?? self.douser, + drinkproof: drinkproof ?? self.drinkproof, + forementioned: forementioned ?? self.forementioned, + freesia: freesia ?? self.freesia, + genevieve: genevieve ?? self.genevieve, + hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical, + hypocone: hypocone ?? self.hypocone, + irreverentially: irreverentially ?? self.irreverentially, + jumart: jumart ?? self.jumart, + mimosaceae: mimosaceae ?? self.mimosaceae, + mollicrush: mollicrush ?? self.mollicrush, + nedder: nedder ?? self.nedder, + retinasphalt: retinasphalt ?? self.retinasphalt, + sough: sough ?? self.sough, + steading: steading ?? self.steading, + theopaschitism: theopaschitism ?? self.theopaschitism, + undurableness: undurableness ?? self.undurableness, + unmingleable: unmingleable ?? self.unmingleable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Retrocervical: Codable, Sendable { + case integer(Int) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Revert: Codable, Sendable { + case bool(Bool) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum RewriteElement: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + case rewriteClass(RewriteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(RewriteClass.self) { + self = .rewriteClass(x) + return + } + throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .rewriteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - RewriteClass +final class RewriteClass: Codable, Sendable { + let accountancy: JSONNull? + let cacotrophic: JSONNull? + let contest: JSONNull? + let couthily: JSONNull? + let falculate: JSONNull? + let foreseize: JSONNull? + let hyades: JSONNull? + let lemnad: JSONNull? + let monotheistically: JSONNull? + let nonflying: JSONNull? + let ptenoglossa: JSONNull? + let repatch: JSONNull? + let rodman: JSONNull? + let strung: JSONNull? + let titmal: JSONNull? + let twalpennyworth: JSONNull? + let unblamable: JSONNull? + let vertical: JSONNull? + let whiggification: JSONNull? + let yardman: JSONNull? + + enum CodingKeys: String, CodingKey { + case accountancy = "accountancy" + case cacotrophic = "cacotrophic" + case contest = "contest" + case couthily = "couthily" + case falculate = "falculate" + case foreseize = "foreseize" + case hyades = "Hyades" + case lemnad = "lemnad" + case monotheistically = "monotheistically" + case nonflying = "nonflying" + case ptenoglossa = "Ptenoglossa" + case repatch = "repatch" + case rodman = "rodman" + case strung = "strung" + case titmal = "titmal" + case twalpennyworth = "twalpennyworth" + case unblamable = "unblamable" + case vertical = "vertical" + case whiggification = "Whiggification" + case yardman = "yardman" + } + + init(accountancy: JSONNull?, cacotrophic: JSONNull?, contest: JSONNull?, couthily: JSONNull?, falculate: JSONNull?, foreseize: JSONNull?, hyades: JSONNull?, lemnad: JSONNull?, monotheistically: JSONNull?, nonflying: JSONNull?, ptenoglossa: JSONNull?, repatch: JSONNull?, rodman: JSONNull?, strung: JSONNull?, titmal: JSONNull?, twalpennyworth: JSONNull?, unblamable: JSONNull?, vertical: JSONNull?, whiggification: JSONNull?, yardman: JSONNull?) { + self.accountancy = accountancy + self.cacotrophic = cacotrophic + self.contest = contest + self.couthily = couthily + self.falculate = falculate + self.foreseize = foreseize + self.hyades = hyades + self.lemnad = lemnad + self.monotheistically = monotheistically + self.nonflying = nonflying + self.ptenoglossa = ptenoglossa + self.repatch = repatch + self.rodman = rodman + self.strung = strung + self.titmal = titmal + self.twalpennyworth = twalpennyworth + self.unblamable = unblamable + self.vertical = vertical + self.whiggification = whiggification + self.yardman = yardman + } +} + +// MARK: RewriteClass convenience initializers and mutators + +extension RewriteClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(RewriteClass.self, from: data) + self.init(accountancy: me.accountancy, cacotrophic: me.cacotrophic, contest: me.contest, couthily: me.couthily, falculate: me.falculate, foreseize: me.foreseize, hyades: me.hyades, lemnad: me.lemnad, monotheistically: me.monotheistically, nonflying: me.nonflying, ptenoglossa: me.ptenoglossa, repatch: me.repatch, rodman: me.rodman, strung: me.strung, titmal: me.titmal, twalpennyworth: me.twalpennyworth, unblamable: me.unblamable, vertical: me.vertical, whiggification: me.whiggification, yardman: me.yardman) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accountancy: JSONNull?? = nil, + cacotrophic: JSONNull?? = nil, + contest: JSONNull?? = nil, + couthily: JSONNull?? = nil, + falculate: JSONNull?? = nil, + foreseize: JSONNull?? = nil, + hyades: JSONNull?? = nil, + lemnad: JSONNull?? = nil, + monotheistically: JSONNull?? = nil, + nonflying: JSONNull?? = nil, + ptenoglossa: JSONNull?? = nil, + repatch: JSONNull?? = nil, + rodman: JSONNull?? = nil, + strung: JSONNull?? = nil, + titmal: JSONNull?? = nil, + twalpennyworth: JSONNull?? = nil, + unblamable: JSONNull?? = nil, + vertical: JSONNull?? = nil, + whiggification: JSONNull?? = nil, + yardman: JSONNull?? = nil + ) -> RewriteClass { + return RewriteClass( + accountancy: accountancy ?? self.accountancy, + cacotrophic: cacotrophic ?? self.cacotrophic, + contest: contest ?? self.contest, + couthily: couthily ?? self.couthily, + falculate: falculate ?? self.falculate, + foreseize: foreseize ?? self.foreseize, + hyades: hyades ?? self.hyades, + lemnad: lemnad ?? self.lemnad, + monotheistically: monotheistically ?? self.monotheistically, + nonflying: nonflying ?? self.nonflying, + ptenoglossa: ptenoglossa ?? self.ptenoglossa, + repatch: repatch ?? self.repatch, + rodman: rodman ?? self.rodman, + strung: strung ?? self.strung, + titmal: titmal ?? self.titmal, + twalpennyworth: twalpennyworth ?? self.twalpennyworth, + unblamable: unblamable ?? self.unblamable, + vertical: vertical ?? self.vertical, + whiggification: whiggification ?? self.whiggification, + yardman: yardman ?? self.yardman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saccoderm: Codable, Sendable { + case integerArray([Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SantirElement: Codable, Sendable { + case double(Double) + case santirClass(SantirClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(SantirClass.self) { + self = .santirClass(x) + return + } + throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .santirClass(let x): + try container.encode(x) + } + } +} + +// MARK: - SantirClass +final class SantirClass: Codable, Sendable { + let admiredly: JSONNull? + let demicaponier: JSONNull? + let epitympanic: JSONNull? + let investitor: JSONNull? + let lupiform: JSONNull? + let monoflagellate: JSONNull? + let paleoethnic: JSONNull? + let prediscountable: JSONNull? + let rhetoricals: JSONNull? + let roomth: JSONNull? + let saccharose: JSONNull? + let septonasal: JSONNull? + let serpenticide: JSONNull? + let setarious: JSONNull? + let spaework: JSONNull? + let stylite: JSONNull? + let suessiones: JSONNull? + let timelily: JSONNull? + let unprofaned: JSONNull? + let vorticular: JSONNull? + + enum CodingKeys: String, CodingKey { + case admiredly = "admiredly" + case demicaponier = "demicaponier" + case epitympanic = "epitympanic" + case investitor = "investitor" + case lupiform = "lupiform" + case monoflagellate = "monoflagellate" + case paleoethnic = "paleoethnic" + case prediscountable = "prediscountable" + case rhetoricals = "rhetoricals" + case roomth = "roomth" + case saccharose = "saccharose" + case septonasal = "septonasal" + case serpenticide = "serpenticide" + case setarious = "setarious" + case spaework = "spaework" + case stylite = "stylite" + case suessiones = "Suessiones" + case timelily = "timelily" + case unprofaned = "unprofaned" + case vorticular = "vorticular" + } + + init(admiredly: JSONNull?, demicaponier: JSONNull?, epitympanic: JSONNull?, investitor: JSONNull?, lupiform: JSONNull?, monoflagellate: JSONNull?, paleoethnic: JSONNull?, prediscountable: JSONNull?, rhetoricals: JSONNull?, roomth: JSONNull?, saccharose: JSONNull?, septonasal: JSONNull?, serpenticide: JSONNull?, setarious: JSONNull?, spaework: JSONNull?, stylite: JSONNull?, suessiones: JSONNull?, timelily: JSONNull?, unprofaned: JSONNull?, vorticular: JSONNull?) { + self.admiredly = admiredly + self.demicaponier = demicaponier + self.epitympanic = epitympanic + self.investitor = investitor + self.lupiform = lupiform + self.monoflagellate = monoflagellate + self.paleoethnic = paleoethnic + self.prediscountable = prediscountable + self.rhetoricals = rhetoricals + self.roomth = roomth + self.saccharose = saccharose + self.septonasal = septonasal + self.serpenticide = serpenticide + self.setarious = setarious + self.spaework = spaework + self.stylite = stylite + self.suessiones = suessiones + self.timelily = timelily + self.unprofaned = unprofaned + self.vorticular = vorticular + } +} + +// MARK: SantirClass convenience initializers and mutators + +extension SantirClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SantirClass.self, from: data) + self.init(admiredly: me.admiredly, demicaponier: me.demicaponier, epitympanic: me.epitympanic, investitor: me.investitor, lupiform: me.lupiform, monoflagellate: me.monoflagellate, paleoethnic: me.paleoethnic, prediscountable: me.prediscountable, rhetoricals: me.rhetoricals, roomth: me.roomth, saccharose: me.saccharose, septonasal: me.septonasal, serpenticide: me.serpenticide, setarious: me.setarious, spaework: me.spaework, stylite: me.stylite, suessiones: me.suessiones, timelily: me.timelily, unprofaned: me.unprofaned, vorticular: me.vorticular) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + admiredly: JSONNull?? = nil, + demicaponier: JSONNull?? = nil, + epitympanic: JSONNull?? = nil, + investitor: JSONNull?? = nil, + lupiform: JSONNull?? = nil, + monoflagellate: JSONNull?? = nil, + paleoethnic: JSONNull?? = nil, + prediscountable: JSONNull?? = nil, + rhetoricals: JSONNull?? = nil, + roomth: JSONNull?? = nil, + saccharose: JSONNull?? = nil, + septonasal: JSONNull?? = nil, + serpenticide: JSONNull?? = nil, + setarious: JSONNull?? = nil, + spaework: JSONNull?? = nil, + stylite: JSONNull?? = nil, + suessiones: JSONNull?? = nil, + timelily: JSONNull?? = nil, + unprofaned: JSONNull?? = nil, + vorticular: JSONNull?? = nil + ) -> SantirClass { + return SantirClass( + admiredly: admiredly ?? self.admiredly, + demicaponier: demicaponier ?? self.demicaponier, + epitympanic: epitympanic ?? self.epitympanic, + investitor: investitor ?? self.investitor, + lupiform: lupiform ?? self.lupiform, + monoflagellate: monoflagellate ?? self.monoflagellate, + paleoethnic: paleoethnic ?? self.paleoethnic, + prediscountable: prediscountable ?? self.prediscountable, + rhetoricals: rhetoricals ?? self.rhetoricals, + roomth: roomth ?? self.roomth, + saccharose: saccharose ?? self.saccharose, + septonasal: septonasal ?? self.septonasal, + serpenticide: serpenticide ?? self.serpenticide, + setarious: setarious ?? self.setarious, + spaework: spaework ?? self.spaework, + stylite: stylite ?? self.stylite, + suessiones: suessiones ?? self.suessiones, + timelily: timelily ?? self.timelily, + unprofaned: unprofaned ?? self.unprofaned, + vorticular: vorticular ?? self.vorticular + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saprophilous: Codable, Sendable { + case integerMap([String: Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SaxtenElement: Codable, Sendable { + case saxtenClass(SaxtenClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(SaxtenClass.self) { + self = .saxtenClass(x) + return + } + throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .saxtenClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - SaxtenClass +final class SaxtenClass: Codable, Sendable { + let algarrobilla: JSONNull? + let bowgrace: JSONNull? + let catharticalness: Double? + let centaurid: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let flix: JSONNull? + let germanely: JSONNull? + let homocerc: Bool? + let inhume: JSONNull? + let lepidote: JSONNull? + let megalochirous: JSONNull? + let ninepenny: JSONNull? + let nonbookish: JSONNull? + let nondeist: JSONNull? + let nymphaeaceous: JSONNull? + let parietofrontal: JSONNull? + let sancyite: JSONNull? + let subjectivist: JSONNull? + let tibiad: JSONNull? + let transonic: JSONNull? + let tripetalous: JSONNull? + let trunchman: JSONNull? + let urger: JSONNull? + let withdrawnness: JSONNull? + + enum CodingKeys: String, CodingKey { + case algarrobilla = "algarrobilla" + case bowgrace = "bowgrace" + case catharticalness = "catharticalness" + case centaurid = "Centaurid" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case flix = "flix" + case germanely = "germanely" + case homocerc = "homocerc" + case inhume = "inhume" + case lepidote = "lepidote" + case megalochirous = "megalochirous" + case ninepenny = "ninepenny" + case nonbookish = "nonbookish" + case nondeist = "nondeist" + case nymphaeaceous = "nymphaeaceous" + case parietofrontal = "parietofrontal" + case sancyite = "sancyite" + case subjectivist = "subjectivist" + case tibiad = "tibiad" + case transonic = "transonic" + case tripetalous = "tripetalous" + case trunchman = "trunchman" + case urger = "urger" + case withdrawnness = "withdrawnness" + } + + init(algarrobilla: JSONNull?, bowgrace: JSONNull?, catharticalness: Double?, centaurid: JSONNull?, chirotherium: Int?, disdiapason: String?, flix: JSONNull?, germanely: JSONNull?, homocerc: Bool?, inhume: JSONNull?, lepidote: JSONNull?, megalochirous: JSONNull?, ninepenny: JSONNull?, nonbookish: JSONNull?, nondeist: JSONNull?, nymphaeaceous: JSONNull?, parietofrontal: JSONNull?, sancyite: JSONNull?, subjectivist: JSONNull?, tibiad: JSONNull?, transonic: JSONNull?, tripetalous: JSONNull?, trunchman: JSONNull?, urger: JSONNull?, withdrawnness: JSONNull?) { + self.algarrobilla = algarrobilla + self.bowgrace = bowgrace + self.catharticalness = catharticalness + self.centaurid = centaurid + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.flix = flix + self.germanely = germanely + self.homocerc = homocerc + self.inhume = inhume + self.lepidote = lepidote + self.megalochirous = megalochirous + self.ninepenny = ninepenny + self.nonbookish = nonbookish + self.nondeist = nondeist + self.nymphaeaceous = nymphaeaceous + self.parietofrontal = parietofrontal + self.sancyite = sancyite + self.subjectivist = subjectivist + self.tibiad = tibiad + self.transonic = transonic + self.tripetalous = tripetalous + self.trunchman = trunchman + self.urger = urger + self.withdrawnness = withdrawnness + } +} + +// MARK: SaxtenClass convenience initializers and mutators + +extension SaxtenClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SaxtenClass.self, from: data) + self.init(algarrobilla: me.algarrobilla, bowgrace: me.bowgrace, catharticalness: me.catharticalness, centaurid: me.centaurid, chirotherium: me.chirotherium, disdiapason: me.disdiapason, flix: me.flix, germanely: me.germanely, homocerc: me.homocerc, inhume: me.inhume, lepidote: me.lepidote, megalochirous: me.megalochirous, ninepenny: me.ninepenny, nonbookish: me.nonbookish, nondeist: me.nondeist, nymphaeaceous: me.nymphaeaceous, parietofrontal: me.parietofrontal, sancyite: me.sancyite, subjectivist: me.subjectivist, tibiad: me.tibiad, transonic: me.transonic, tripetalous: me.tripetalous, trunchman: me.trunchman, urger: me.urger, withdrawnness: me.withdrawnness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + algarrobilla: JSONNull?? = nil, + bowgrace: JSONNull?? = nil, + catharticalness: Double?? = nil, + centaurid: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + flix: JSONNull?? = nil, + germanely: JSONNull?? = nil, + homocerc: Bool?? = nil, + inhume: JSONNull?? = nil, + lepidote: JSONNull?? = nil, + megalochirous: JSONNull?? = nil, + ninepenny: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nondeist: JSONNull?? = nil, + nymphaeaceous: JSONNull?? = nil, + parietofrontal: JSONNull?? = nil, + sancyite: JSONNull?? = nil, + subjectivist: JSONNull?? = nil, + tibiad: JSONNull?? = nil, + transonic: JSONNull?? = nil, + tripetalous: JSONNull?? = nil, + trunchman: JSONNull?? = nil, + urger: JSONNull?? = nil, + withdrawnness: JSONNull?? = nil + ) -> SaxtenClass { + return SaxtenClass( + algarrobilla: algarrobilla ?? self.algarrobilla, + bowgrace: bowgrace ?? self.bowgrace, + catharticalness: catharticalness ?? self.catharticalness, + centaurid: centaurid ?? self.centaurid, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + flix: flix ?? self.flix, + germanely: germanely ?? self.germanely, + homocerc: homocerc ?? self.homocerc, + inhume: inhume ?? self.inhume, + lepidote: lepidote ?? self.lepidote, + megalochirous: megalochirous ?? self.megalochirous, + ninepenny: ninepenny ?? self.ninepenny, + nonbookish: nonbookish ?? self.nonbookish, + nondeist: nondeist ?? self.nondeist, + nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous, + parietofrontal: parietofrontal ?? self.parietofrontal, + sancyite: sancyite ?? self.sancyite, + subjectivist: subjectivist ?? self.subjectivist, + tibiad: tibiad ?? self.tibiad, + transonic: transonic ?? self.transonic, + tripetalous: tripetalous ?? self.tripetalous, + trunchman: trunchman ?? self.trunchman, + urger: urger ?? self.urger, + withdrawnness: withdrawnness ?? self.withdrawnness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Scatty +final class Scatty: Codable, Sendable { + let aeriferous: JSONNull? + let antical: JSONNull? + let antighostism: JSONNull? + let arcanum: JSONNull? + let autotrophy: JSONNull? + let baronial: JSONNull? + let caffeine: JSONNull? + let gorgoniacean: JSONNull? + let heroical: JSONNull? + let hydropical: JSONNull? + let mechanology: JSONNull? + let musicopoetic: JSONNull? + let officiality: JSONNull? + let oftentimes: JSONNull? + let ophthalmotonometer: JSONNull? + let reflectively: JSONNull? + let springer: JSONNull? + let tabasco: JSONNull? + let teleianthous: JSONNull? + let uncombated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeriferous = "aeriferous" + case antical = "antical" + case antighostism = "antighostism" + case arcanum = "arcanum" + case autotrophy = "autotrophy" + case baronial = "baronial" + case caffeine = "caffeine" + case gorgoniacean = "gorgoniacean" + case heroical = "heroical" + case hydropical = "hydropical" + case mechanology = "mechanology" + case musicopoetic = "musicopoetic" + case officiality = "officiality" + case oftentimes = "oftentimes" + case ophthalmotonometer = "ophthalmotonometer" + case reflectively = "reflectively" + case springer = "springer" + case tabasco = "Tabasco" + case teleianthous = "teleianthous" + case uncombated = "uncombated" + } + + init(aeriferous: JSONNull?, antical: JSONNull?, antighostism: JSONNull?, arcanum: JSONNull?, autotrophy: JSONNull?, baronial: JSONNull?, caffeine: JSONNull?, gorgoniacean: JSONNull?, heroical: JSONNull?, hydropical: JSONNull?, mechanology: JSONNull?, musicopoetic: JSONNull?, officiality: JSONNull?, oftentimes: JSONNull?, ophthalmotonometer: JSONNull?, reflectively: JSONNull?, springer: JSONNull?, tabasco: JSONNull?, teleianthous: JSONNull?, uncombated: JSONNull?) { + self.aeriferous = aeriferous + self.antical = antical + self.antighostism = antighostism + self.arcanum = arcanum + self.autotrophy = autotrophy + self.baronial = baronial + self.caffeine = caffeine + self.gorgoniacean = gorgoniacean + self.heroical = heroical + self.hydropical = hydropical + self.mechanology = mechanology + self.musicopoetic = musicopoetic + self.officiality = officiality + self.oftentimes = oftentimes + self.ophthalmotonometer = ophthalmotonometer + self.reflectively = reflectively + self.springer = springer + self.tabasco = tabasco + self.teleianthous = teleianthous + self.uncombated = uncombated + } +} + +// MARK: Scatty convenience initializers and mutators + +extension Scatty { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Scatty.self, from: data) + self.init(aeriferous: me.aeriferous, antical: me.antical, antighostism: me.antighostism, arcanum: me.arcanum, autotrophy: me.autotrophy, baronial: me.baronial, caffeine: me.caffeine, gorgoniacean: me.gorgoniacean, heroical: me.heroical, hydropical: me.hydropical, mechanology: me.mechanology, musicopoetic: me.musicopoetic, officiality: me.officiality, oftentimes: me.oftentimes, ophthalmotonometer: me.ophthalmotonometer, reflectively: me.reflectively, springer: me.springer, tabasco: me.tabasco, teleianthous: me.teleianthous, uncombated: me.uncombated) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeriferous: JSONNull?? = nil, + antical: JSONNull?? = nil, + antighostism: JSONNull?? = nil, + arcanum: JSONNull?? = nil, + autotrophy: JSONNull?? = nil, + baronial: JSONNull?? = nil, + caffeine: JSONNull?? = nil, + gorgoniacean: JSONNull?? = nil, + heroical: JSONNull?? = nil, + hydropical: JSONNull?? = nil, + mechanology: JSONNull?? = nil, + musicopoetic: JSONNull?? = nil, + officiality: JSONNull?? = nil, + oftentimes: JSONNull?? = nil, + ophthalmotonometer: JSONNull?? = nil, + reflectively: JSONNull?? = nil, + springer: JSONNull?? = nil, + tabasco: JSONNull?? = nil, + teleianthous: JSONNull?? = nil, + uncombated: JSONNull?? = nil + ) -> Scatty { + return Scatty( + aeriferous: aeriferous ?? self.aeriferous, + antical: antical ?? self.antical, + antighostism: antighostism ?? self.antighostism, + arcanum: arcanum ?? self.arcanum, + autotrophy: autotrophy ?? self.autotrophy, + baronial: baronial ?? self.baronial, + caffeine: caffeine ?? self.caffeine, + gorgoniacean: gorgoniacean ?? self.gorgoniacean, + heroical: heroical ?? self.heroical, + hydropical: hydropical ?? self.hydropical, + mechanology: mechanology ?? self.mechanology, + musicopoetic: musicopoetic ?? self.musicopoetic, + officiality: officiality ?? self.officiality, + oftentimes: oftentimes ?? self.oftentimes, + ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer, + reflectively: reflectively ?? self.reflectively, + springer: springer ?? self.springer, + tabasco: tabasco ?? self.tabasco, + teleianthous: teleianthous ?? self.teleianthous, + uncombated: uncombated ?? self.uncombated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Scoffer: Codable, Sendable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Scrampum: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Serpentinic: Codable, Sendable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Shadowable: Codable, Sendable { + case bool(Bool) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum SisteringElement: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + case sisteringClass(SisteringClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(SisteringClass.self) { + self = .sisteringClass(x) + return + } + throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .sisteringClass(let x): + try container.encode(x) + } + } +} + +// MARK: - SisteringClass +final class SisteringClass: Codable, Sendable { + let amphicarpic: JSONNull? + let chianti: JSONNull? + let frigorific: JSONNull? + let haplomi: JSONNull? + let hyperkinesis: JSONNull? + let laudable: JSONNull? + let madwoman: JSONNull? + let maimedly: JSONNull? + let micropterygidae: JSONNull? + let microrhabdus: JSONNull? + let nondense: JSONNull? + let phlebemphraxis: JSONNull? + let redsear: JSONNull? + let schismatical: JSONNull? + let tartryl: JSONNull? + let unabhorred: JSONNull? + let undeliberateness: JSONNull? + let unmixable: JSONNull? + let untruckling: JSONNull? + let vineal: JSONNull? + + enum CodingKeys: String, CodingKey { + case amphicarpic = "amphicarpic" + case chianti = "Chianti" + case frigorific = "frigorific" + case haplomi = "Haplomi" + case hyperkinesis = "hyperkinesis" + case laudable = "laudable" + case madwoman = "madwoman" + case maimedly = "maimedly" + case micropterygidae = "Micropterygidae" + case microrhabdus = "microrhabdus" + case nondense = "nondense" + case phlebemphraxis = "phlebemphraxis" + case redsear = "redsear" + case schismatical = "schismatical" + case tartryl = "tartryl" + case unabhorred = "unabhorred" + case undeliberateness = "undeliberateness" + case unmixable = "unmixable" + case untruckling = "untruckling" + case vineal = "vineal" + } + + init(amphicarpic: JSONNull?, chianti: JSONNull?, frigorific: JSONNull?, haplomi: JSONNull?, hyperkinesis: JSONNull?, laudable: JSONNull?, madwoman: JSONNull?, maimedly: JSONNull?, micropterygidae: JSONNull?, microrhabdus: JSONNull?, nondense: JSONNull?, phlebemphraxis: JSONNull?, redsear: JSONNull?, schismatical: JSONNull?, tartryl: JSONNull?, unabhorred: JSONNull?, undeliberateness: JSONNull?, unmixable: JSONNull?, untruckling: JSONNull?, vineal: JSONNull?) { + self.amphicarpic = amphicarpic + self.chianti = chianti + self.frigorific = frigorific + self.haplomi = haplomi + self.hyperkinesis = hyperkinesis + self.laudable = laudable + self.madwoman = madwoman + self.maimedly = maimedly + self.micropterygidae = micropterygidae + self.microrhabdus = microrhabdus + self.nondense = nondense + self.phlebemphraxis = phlebemphraxis + self.redsear = redsear + self.schismatical = schismatical + self.tartryl = tartryl + self.unabhorred = unabhorred + self.undeliberateness = undeliberateness + self.unmixable = unmixable + self.untruckling = untruckling + self.vineal = vineal + } +} + +// MARK: SisteringClass convenience initializers and mutators + +extension SisteringClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SisteringClass.self, from: data) + self.init(amphicarpic: me.amphicarpic, chianti: me.chianti, frigorific: me.frigorific, haplomi: me.haplomi, hyperkinesis: me.hyperkinesis, laudable: me.laudable, madwoman: me.madwoman, maimedly: me.maimedly, micropterygidae: me.micropterygidae, microrhabdus: me.microrhabdus, nondense: me.nondense, phlebemphraxis: me.phlebemphraxis, redsear: me.redsear, schismatical: me.schismatical, tartryl: me.tartryl, unabhorred: me.unabhorred, undeliberateness: me.undeliberateness, unmixable: me.unmixable, untruckling: me.untruckling, vineal: me.vineal) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amphicarpic: JSONNull?? = nil, + chianti: JSONNull?? = nil, + frigorific: JSONNull?? = nil, + haplomi: JSONNull?? = nil, + hyperkinesis: JSONNull?? = nil, + laudable: JSONNull?? = nil, + madwoman: JSONNull?? = nil, + maimedly: JSONNull?? = nil, + micropterygidae: JSONNull?? = nil, + microrhabdus: JSONNull?? = nil, + nondense: JSONNull?? = nil, + phlebemphraxis: JSONNull?? = nil, + redsear: JSONNull?? = nil, + schismatical: JSONNull?? = nil, + tartryl: JSONNull?? = nil, + unabhorred: JSONNull?? = nil, + undeliberateness: JSONNull?? = nil, + unmixable: JSONNull?? = nil, + untruckling: JSONNull?? = nil, + vineal: JSONNull?? = nil + ) -> SisteringClass { + return SisteringClass( + amphicarpic: amphicarpic ?? self.amphicarpic, + chianti: chianti ?? self.chianti, + frigorific: frigorific ?? self.frigorific, + haplomi: haplomi ?? self.haplomi, + hyperkinesis: hyperkinesis ?? self.hyperkinesis, + laudable: laudable ?? self.laudable, + madwoman: madwoman ?? self.madwoman, + maimedly: maimedly ?? self.maimedly, + micropterygidae: micropterygidae ?? self.micropterygidae, + microrhabdus: microrhabdus ?? self.microrhabdus, + nondense: nondense ?? self.nondense, + phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis, + redsear: redsear ?? self.redsear, + schismatical: schismatical ?? self.schismatical, + tartryl: tartryl ?? self.tartryl, + unabhorred: unabhorred ?? self.unabhorred, + undeliberateness: undeliberateness ?? self.undeliberateness, + unmixable: unmixable ?? self.unmixable, + untruckling: untruckling ?? self.untruckling, + vineal: vineal ?? self.vineal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Staghunting +final class Staghunting: Codable, Sendable { + let calorimetric: Int? + let canid: Int? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ditriglyphic: Int? + let floriferousness: Int? + let gamelike: Int? + let grig: Int? + let homocerc: Bool? + let interloan: Int? + let lithotomy: Int? + let loric: Int? + let membranocoriaceous: Int? + let membranogenic: Int? + let nonbookish: JSONNull? + let overtrump: Int? + let scotino: Int? + let seasonable: Int? + let sephen: Int? + let stigmarioid: Int? + let tired: Int? + let trifid: Int? + let undefeatedly: Int? + let ungirlish: Int? + + enum CodingKeys: String, CodingKey { + case calorimetric = "calorimetric" + case canid = "canid" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ditriglyphic = "ditriglyphic" + case floriferousness = "floriferousness" + case gamelike = "gamelike" + case grig = "grig" + case homocerc = "homocerc" + case interloan = "interloan" + case lithotomy = "lithotomy" + case loric = "loric" + case membranocoriaceous = "membranocoriaceous" + case membranogenic = "membranogenic" + case nonbookish = "nonbookish" + case overtrump = "overtrump" + case scotino = "scotino" + case seasonable = "seasonable" + case sephen = "sephen" + case stigmarioid = "stigmarioid" + case tired = "tired" + case trifid = "trifid" + case undefeatedly = "undefeatedly" + case ungirlish = "ungirlish" + } + + init(calorimetric: Int?, canid: Int?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ditriglyphic: Int?, floriferousness: Int?, gamelike: Int?, grig: Int?, homocerc: Bool?, interloan: Int?, lithotomy: Int?, loric: Int?, membranocoriaceous: Int?, membranogenic: Int?, nonbookish: JSONNull?, overtrump: Int?, scotino: Int?, seasonable: Int?, sephen: Int?, stigmarioid: Int?, tired: Int?, trifid: Int?, undefeatedly: Int?, ungirlish: Int?) { + self.calorimetric = calorimetric + self.canid = canid + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ditriglyphic = ditriglyphic + self.floriferousness = floriferousness + self.gamelike = gamelike + self.grig = grig + self.homocerc = homocerc + self.interloan = interloan + self.lithotomy = lithotomy + self.loric = loric + self.membranocoriaceous = membranocoriaceous + self.membranogenic = membranogenic + self.nonbookish = nonbookish + self.overtrump = overtrump + self.scotino = scotino + self.seasonable = seasonable + self.sephen = sephen + self.stigmarioid = stigmarioid + self.tired = tired + self.trifid = trifid + self.undefeatedly = undefeatedly + self.ungirlish = ungirlish + } +} + +// MARK: Staghunting convenience initializers and mutators + +extension Staghunting { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Staghunting.self, from: data) + self.init(calorimetric: me.calorimetric, canid: me.canid, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ditriglyphic: me.ditriglyphic, floriferousness: me.floriferousness, gamelike: me.gamelike, grig: me.grig, homocerc: me.homocerc, interloan: me.interloan, lithotomy: me.lithotomy, loric: me.loric, membranocoriaceous: me.membranocoriaceous, membranogenic: me.membranogenic, nonbookish: me.nonbookish, overtrump: me.overtrump, scotino: me.scotino, seasonable: me.seasonable, sephen: me.sephen, stigmarioid: me.stigmarioid, tired: me.tired, trifid: me.trifid, undefeatedly: me.undefeatedly, ungirlish: me.ungirlish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + calorimetric: Int?? = nil, + canid: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ditriglyphic: Int?? = nil, + floriferousness: Int?? = nil, + gamelike: Int?? = nil, + grig: Int?? = nil, + homocerc: Bool?? = nil, + interloan: Int?? = nil, + lithotomy: Int?? = nil, + loric: Int?? = nil, + membranocoriaceous: Int?? = nil, + membranogenic: Int?? = nil, + nonbookish: JSONNull?? = nil, + overtrump: Int?? = nil, + scotino: Int?? = nil, + seasonable: Int?? = nil, + sephen: Int?? = nil, + stigmarioid: Int?? = nil, + tired: Int?? = nil, + trifid: Int?? = nil, + undefeatedly: Int?? = nil, + ungirlish: Int?? = nil + ) -> Staghunting { + return Staghunting( + calorimetric: calorimetric ?? self.calorimetric, + canid: canid ?? self.canid, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ditriglyphic: ditriglyphic ?? self.ditriglyphic, + floriferousness: floriferousness ?? self.floriferousness, + gamelike: gamelike ?? self.gamelike, + grig: grig ?? self.grig, + homocerc: homocerc ?? self.homocerc, + interloan: interloan ?? self.interloan, + lithotomy: lithotomy ?? self.lithotomy, + loric: loric ?? self.loric, + membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous, + membranogenic: membranogenic ?? self.membranogenic, + nonbookish: nonbookish ?? self.nonbookish, + overtrump: overtrump ?? self.overtrump, + scotino: scotino ?? self.scotino, + seasonable: seasonable ?? self.seasonable, + sephen: sephen ?? self.sephen, + stigmarioid: stigmarioid ?? self.stigmarioid, + tired: tired ?? self.tired, + trifid: trifid ?? self.trifid, + undefeatedly: undefeatedly ?? self.undefeatedly, + ungirlish: ungirlish ?? self.ungirlish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Stagmometer: Codable, Sendable { + case string(String) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Stimulability: Codable, Sendable { + case bool(Bool) + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Strangleable: Codable, Sendable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum StrenuosityElement: Codable, Sendable { + case nullArray([JSONNull?]) + case strenuosityClass(StrenuosityClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(StrenuosityClass.self) { + self = .strenuosityClass(x) + return + } + throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .strenuosityClass(let x): + try container.encode(x) + } + } +} + +// MARK: - StrenuosityClass +final class StrenuosityClass: Codable, Sendable { + let bliss: Int? + let buccate: Int? + let bulletproof: Int? + let catharticalness: Double? + let chirotherium: Int? + let crumblingness: Int? + let disdiapason: String? + let engagedly: Int? + let fightable: Int? + let hoariness: Int? + let homocerc: Bool? + let hypopodium: Int? + let luxurist: Int? + let mechanician: Int? + let nonbookish: JSONNull? + let onopordon: Int? + let podgily: Int? + let reformableness: Int? + let scatterbrains: Int? + let seminuria: Int? + let sodomite: Int? + let tramp: Int? + let undueness: Int? + let worthily: Int? + let yankeeist: Int? + + enum CodingKeys: String, CodingKey { + case bliss = "bliss" + case buccate = "buccate" + case bulletproof = "bulletproof" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case crumblingness = "crumblingness" + case disdiapason = "disdiapason" + case engagedly = "engagedly" + case fightable = "fightable" + case hoariness = "hoariness" + case homocerc = "homocerc" + case hypopodium = "hypopodium" + case luxurist = "luxurist" + case mechanician = "mechanician" + case nonbookish = "nonbookish" + case onopordon = "Onopordon" + case podgily = "podgily" + case reformableness = "reformableness" + case scatterbrains = "scatterbrains" + case seminuria = "seminuria" + case sodomite = "Sodomite" + case tramp = "tramp" + case undueness = "undueness" + case worthily = "worthily" + case yankeeist = "Yankeeist" + } + + init(bliss: Int?, buccate: Int?, bulletproof: Int?, catharticalness: Double?, chirotherium: Int?, crumblingness: Int?, disdiapason: String?, engagedly: Int?, fightable: Int?, hoariness: Int?, homocerc: Bool?, hypopodium: Int?, luxurist: Int?, mechanician: Int?, nonbookish: JSONNull?, onopordon: Int?, podgily: Int?, reformableness: Int?, scatterbrains: Int?, seminuria: Int?, sodomite: Int?, tramp: Int?, undueness: Int?, worthily: Int?, yankeeist: Int?) { + self.bliss = bliss + self.buccate = buccate + self.bulletproof = bulletproof + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.crumblingness = crumblingness + self.disdiapason = disdiapason + self.engagedly = engagedly + self.fightable = fightable + self.hoariness = hoariness + self.homocerc = homocerc + self.hypopodium = hypopodium + self.luxurist = luxurist + self.mechanician = mechanician + self.nonbookish = nonbookish + self.onopordon = onopordon + self.podgily = podgily + self.reformableness = reformableness + self.scatterbrains = scatterbrains + self.seminuria = seminuria + self.sodomite = sodomite + self.tramp = tramp + self.undueness = undueness + self.worthily = worthily + self.yankeeist = yankeeist + } +} + +// MARK: StrenuosityClass convenience initializers and mutators + +extension StrenuosityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(StrenuosityClass.self, from: data) + self.init(bliss: me.bliss, buccate: me.buccate, bulletproof: me.bulletproof, catharticalness: me.catharticalness, chirotherium: me.chirotherium, crumblingness: me.crumblingness, disdiapason: me.disdiapason, engagedly: me.engagedly, fightable: me.fightable, hoariness: me.hoariness, homocerc: me.homocerc, hypopodium: me.hypopodium, luxurist: me.luxurist, mechanician: me.mechanician, nonbookish: me.nonbookish, onopordon: me.onopordon, podgily: me.podgily, reformableness: me.reformableness, scatterbrains: me.scatterbrains, seminuria: me.seminuria, sodomite: me.sodomite, tramp: me.tramp, undueness: me.undueness, worthily: me.worthily, yankeeist: me.yankeeist) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bliss: Int?? = nil, + buccate: Int?? = nil, + bulletproof: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + crumblingness: Int?? = nil, + disdiapason: String?? = nil, + engagedly: Int?? = nil, + fightable: Int?? = nil, + hoariness: Int?? = nil, + homocerc: Bool?? = nil, + hypopodium: Int?? = nil, + luxurist: Int?? = nil, + mechanician: Int?? = nil, + nonbookish: JSONNull?? = nil, + onopordon: Int?? = nil, + podgily: Int?? = nil, + reformableness: Int?? = nil, + scatterbrains: Int?? = nil, + seminuria: Int?? = nil, + sodomite: Int?? = nil, + tramp: Int?? = nil, + undueness: Int?? = nil, + worthily: Int?? = nil, + yankeeist: Int?? = nil + ) -> StrenuosityClass { + return StrenuosityClass( + bliss: bliss ?? self.bliss, + buccate: buccate ?? self.buccate, + bulletproof: bulletproof ?? self.bulletproof, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + crumblingness: crumblingness ?? self.crumblingness, + disdiapason: disdiapason ?? self.disdiapason, + engagedly: engagedly ?? self.engagedly, + fightable: fightable ?? self.fightable, + hoariness: hoariness ?? self.hoariness, + homocerc: homocerc ?? self.homocerc, + hypopodium: hypopodium ?? self.hypopodium, + luxurist: luxurist ?? self.luxurist, + mechanician: mechanician ?? self.mechanician, + nonbookish: nonbookish ?? self.nonbookish, + onopordon: onopordon ?? self.onopordon, + podgily: podgily ?? self.podgily, + reformableness: reformableness ?? self.reformableness, + scatterbrains: scatterbrains ?? self.scatterbrains, + seminuria: seminuria ?? self.seminuria, + sodomite: sodomite ?? self.sodomite, + tramp: tramp ?? self.tramp, + undueness: undueness ?? self.undueness, + worthily: worthily ?? self.worthily, + yankeeist: yankeeist ?? self.yankeeist + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Tabaxir: Codable, Sendable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Talpiform: Codable, Sendable { + case double(Double) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Thwack: Codable, Sendable { + case bool(Bool) + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum Tortricine: Codable, Sendable { + case quebrachineClass(QuebrachineClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .quebrachineClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum TruantcyElement: Codable, Sendable { + case bool(Bool) + case truantcyClass(TruantcyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TruantcyClass.self) { + self = .truantcyClass(x) + return + } + throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .truantcyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - TruantcyClass +final class TruantcyClass: Codable, Sendable { + let alfiona: JSONNull? + let ascaridiasis: JSONNull? + let bungey: JSONNull? + let catharticalness: Double? + let ceroxyle: JSONNull? + let chirotherium: Int? + let chorology: JSONNull? + let disdiapason: String? + let enmarble: JSONNull? + let epeira: JSONNull? + let eurylaimi: JSONNull? + let germination: JSONNull? + let hallelujah: JSONNull? + let homocerc: Bool? + let lev: JSONNull? + let mouthing: JSONNull? + let nonbookish: JSONNull? + let philliloo: JSONNull? + let planetal: JSONNull? + let poney: JSONNull? + let punctualist: JSONNull? + let returnlessly: JSONNull? + let skelder: JSONNull? + let windwaywardly: JSONNull? + let yuman: JSONNull? + + enum CodingKeys: String, CodingKey { + case alfiona = "alfiona" + case ascaridiasis = "ascaridiasis" + case bungey = "bungey" + case catharticalness = "catharticalness" + case ceroxyle = "ceroxyle" + case chirotherium = "Chirotherium" + case chorology = "chorology" + case disdiapason = "disdiapason" + case enmarble = "enmarble" + case epeira = "Epeira" + case eurylaimi = "Eurylaimi" + case germination = "germination" + case hallelujah = "hallelujah" + case homocerc = "homocerc" + case lev = "lev" + case mouthing = "mouthing" + case nonbookish = "nonbookish" + case philliloo = "philliloo" + case planetal = "planetal" + case poney = "poney" + case punctualist = "punctualist" + case returnlessly = "returnlessly" + case skelder = "skelder" + case windwaywardly = "windwaywardly" + case yuman = "Yuman" + } + + init(alfiona: JSONNull?, ascaridiasis: JSONNull?, bungey: JSONNull?, catharticalness: Double?, ceroxyle: JSONNull?, chirotherium: Int?, chorology: JSONNull?, disdiapason: String?, enmarble: JSONNull?, epeira: JSONNull?, eurylaimi: JSONNull?, germination: JSONNull?, hallelujah: JSONNull?, homocerc: Bool?, lev: JSONNull?, mouthing: JSONNull?, nonbookish: JSONNull?, philliloo: JSONNull?, planetal: JSONNull?, poney: JSONNull?, punctualist: JSONNull?, returnlessly: JSONNull?, skelder: JSONNull?, windwaywardly: JSONNull?, yuman: JSONNull?) { + self.alfiona = alfiona + self.ascaridiasis = ascaridiasis + self.bungey = bungey + self.catharticalness = catharticalness + self.ceroxyle = ceroxyle + self.chirotherium = chirotherium + self.chorology = chorology + self.disdiapason = disdiapason + self.enmarble = enmarble + self.epeira = epeira + self.eurylaimi = eurylaimi + self.germination = germination + self.hallelujah = hallelujah + self.homocerc = homocerc + self.lev = lev + self.mouthing = mouthing + self.nonbookish = nonbookish + self.philliloo = philliloo + self.planetal = planetal + self.poney = poney + self.punctualist = punctualist + self.returnlessly = returnlessly + self.skelder = skelder + self.windwaywardly = windwaywardly + self.yuman = yuman + } +} + +// MARK: TruantcyClass convenience initializers and mutators + +extension TruantcyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TruantcyClass.self, from: data) + self.init(alfiona: me.alfiona, ascaridiasis: me.ascaridiasis, bungey: me.bungey, catharticalness: me.catharticalness, ceroxyle: me.ceroxyle, chirotherium: me.chirotherium, chorology: me.chorology, disdiapason: me.disdiapason, enmarble: me.enmarble, epeira: me.epeira, eurylaimi: me.eurylaimi, germination: me.germination, hallelujah: me.hallelujah, homocerc: me.homocerc, lev: me.lev, mouthing: me.mouthing, nonbookish: me.nonbookish, philliloo: me.philliloo, planetal: me.planetal, poney: me.poney, punctualist: me.punctualist, returnlessly: me.returnlessly, skelder: me.skelder, windwaywardly: me.windwaywardly, yuman: me.yuman) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alfiona: JSONNull?? = nil, + ascaridiasis: JSONNull?? = nil, + bungey: JSONNull?? = nil, + catharticalness: Double?? = nil, + ceroxyle: JSONNull?? = nil, + chirotherium: Int?? = nil, + chorology: JSONNull?? = nil, + disdiapason: String?? = nil, + enmarble: JSONNull?? = nil, + epeira: JSONNull?? = nil, + eurylaimi: JSONNull?? = nil, + germination: JSONNull?? = nil, + hallelujah: JSONNull?? = nil, + homocerc: Bool?? = nil, + lev: JSONNull?? = nil, + mouthing: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + philliloo: JSONNull?? = nil, + planetal: JSONNull?? = nil, + poney: JSONNull?? = nil, + punctualist: JSONNull?? = nil, + returnlessly: JSONNull?? = nil, + skelder: JSONNull?? = nil, + windwaywardly: JSONNull?? = nil, + yuman: JSONNull?? = nil + ) -> TruantcyClass { + return TruantcyClass( + alfiona: alfiona ?? self.alfiona, + ascaridiasis: ascaridiasis ?? self.ascaridiasis, + bungey: bungey ?? self.bungey, + catharticalness: catharticalness ?? self.catharticalness, + ceroxyle: ceroxyle ?? self.ceroxyle, + chirotherium: chirotherium ?? self.chirotherium, + chorology: chorology ?? self.chorology, + disdiapason: disdiapason ?? self.disdiapason, + enmarble: enmarble ?? self.enmarble, + epeira: epeira ?? self.epeira, + eurylaimi: eurylaimi ?? self.eurylaimi, + germination: germination ?? self.germination, + hallelujah: hallelujah ?? self.hallelujah, + homocerc: homocerc ?? self.homocerc, + lev: lev ?? self.lev, + mouthing: mouthing ?? self.mouthing, + nonbookish: nonbookish ?? self.nonbookish, + philliloo: philliloo ?? self.philliloo, + planetal: planetal ?? self.planetal, + poney: poney ?? self.poney, + punctualist: punctualist ?? self.punctualist, + returnlessly: returnlessly ?? self.returnlessly, + skelder: skelder ?? self.skelder, + windwaywardly: windwaywardly ?? self.windwaywardly, + yuman: yuman ?? self.yuman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unbeginning: Codable, Sendable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Undesirability: Codable, Sendable { + case integerArray([Int]) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unerasing: Codable, Sendable { + case integer(Int) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unguentarium: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum UnimpeachablyElement: Codable, Sendable { + case bool(Bool) + case unimpeachablyClass(UnimpeachablyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(UnimpeachablyClass.self) { + self = .unimpeachablyClass(x) + return + } + throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unimpeachablyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - UnimpeachablyClass +final class UnimpeachablyClass: Codable, Sendable { + let acerin: Int? + let bobadil: Int? + let catharticalness: Double? + let chirotherium: Int? + let chlorophylligenous: Int? + let conversational: Int? + let demiowl: Int? + let disdiapason: String? + let ectorhinal: Int? + let gamblesomeness: Int? + let homocerc: Bool? + let irrorate: Int? + let kindergartening: Int? + let lateritic: Int? + let mespil: Int? + let misconfiguration: Int? + let nonbookish: JSONNull? + let planometry: Int? + let quiina: Int? + let robert: Int? + let rot: Int? + let subcinctorium: Int? + let tussocker: Int? + let ultraproud: Int? + let unsuggestedness: Int? + + enum CodingKeys: String, CodingKey { + case acerin = "acerin" + case bobadil = "Bobadil" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorophylligenous = "chlorophylligenous" + case conversational = "conversational" + case demiowl = "demiowl" + case disdiapason = "disdiapason" + case ectorhinal = "ectorhinal" + case gamblesomeness = "gamblesomeness" + case homocerc = "homocerc" + case irrorate = "irrorate" + case kindergartening = "kindergartening" + case lateritic = "lateritic" + case mespil = "mespil" + case misconfiguration = "misconfiguration" + case nonbookish = "nonbookish" + case planometry = "planometry" + case quiina = "Quiina" + case robert = "Robert" + case rot = "rot" + case subcinctorium = "subcinctorium" + case tussocker = "tussocker" + case ultraproud = "ultraproud" + case unsuggestedness = "unsuggestedness" + } + + init(acerin: Int?, bobadil: Int?, catharticalness: Double?, chirotherium: Int?, chlorophylligenous: Int?, conversational: Int?, demiowl: Int?, disdiapason: String?, ectorhinal: Int?, gamblesomeness: Int?, homocerc: Bool?, irrorate: Int?, kindergartening: Int?, lateritic: Int?, mespil: Int?, misconfiguration: Int?, nonbookish: JSONNull?, planometry: Int?, quiina: Int?, robert: Int?, rot: Int?, subcinctorium: Int?, tussocker: Int?, ultraproud: Int?, unsuggestedness: Int?) { + self.acerin = acerin + self.bobadil = bobadil + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chlorophylligenous = chlorophylligenous + self.conversational = conversational + self.demiowl = demiowl + self.disdiapason = disdiapason + self.ectorhinal = ectorhinal + self.gamblesomeness = gamblesomeness + self.homocerc = homocerc + self.irrorate = irrorate + self.kindergartening = kindergartening + self.lateritic = lateritic + self.mespil = mespil + self.misconfiguration = misconfiguration + self.nonbookish = nonbookish + self.planometry = planometry + self.quiina = quiina + self.robert = robert + self.rot = rot + self.subcinctorium = subcinctorium + self.tussocker = tussocker + self.ultraproud = ultraproud + self.unsuggestedness = unsuggestedness + } +} + +// MARK: UnimpeachablyClass convenience initializers and mutators + +extension UnimpeachablyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data) + self.init(acerin: me.acerin, bobadil: me.bobadil, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chlorophylligenous: me.chlorophylligenous, conversational: me.conversational, demiowl: me.demiowl, disdiapason: me.disdiapason, ectorhinal: me.ectorhinal, gamblesomeness: me.gamblesomeness, homocerc: me.homocerc, irrorate: me.irrorate, kindergartening: me.kindergartening, lateritic: me.lateritic, mespil: me.mespil, misconfiguration: me.misconfiguration, nonbookish: me.nonbookish, planometry: me.planometry, quiina: me.quiina, robert: me.robert, rot: me.rot, subcinctorium: me.subcinctorium, tussocker: me.tussocker, ultraproud: me.ultraproud, unsuggestedness: me.unsuggestedness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acerin: Int?? = nil, + bobadil: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorophylligenous: Int?? = nil, + conversational: Int?? = nil, + demiowl: Int?? = nil, + disdiapason: String?? = nil, + ectorhinal: Int?? = nil, + gamblesomeness: Int?? = nil, + homocerc: Bool?? = nil, + irrorate: Int?? = nil, + kindergartening: Int?? = nil, + lateritic: Int?? = nil, + mespil: Int?? = nil, + misconfiguration: Int?? = nil, + nonbookish: JSONNull?? = nil, + planometry: Int?? = nil, + quiina: Int?? = nil, + robert: Int?? = nil, + rot: Int?? = nil, + subcinctorium: Int?? = nil, + tussocker: Int?? = nil, + ultraproud: Int?? = nil, + unsuggestedness: Int?? = nil + ) -> UnimpeachablyClass { + return UnimpeachablyClass( + acerin: acerin ?? self.acerin, + bobadil: bobadil ?? self.bobadil, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous, + conversational: conversational ?? self.conversational, + demiowl: demiowl ?? self.demiowl, + disdiapason: disdiapason ?? self.disdiapason, + ectorhinal: ectorhinal ?? self.ectorhinal, + gamblesomeness: gamblesomeness ?? self.gamblesomeness, + homocerc: homocerc ?? self.homocerc, + irrorate: irrorate ?? self.irrorate, + kindergartening: kindergartening ?? self.kindergartening, + lateritic: lateritic ?? self.lateritic, + mespil: mespil ?? self.mespil, + misconfiguration: misconfiguration ?? self.misconfiguration, + nonbookish: nonbookish ?? self.nonbookish, + planometry: planometry ?? self.planometry, + quiina: quiina ?? self.quiina, + robert: robert ?? self.robert, + rot: rot ?? self.rot, + subcinctorium: subcinctorium ?? self.subcinctorium, + tussocker: tussocker ?? self.tussocker, + ultraproud: ultraproud ?? self.ultraproud, + unsuggestedness: unsuggestedness ?? self.unsuggestedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unmortgaged: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unobstructed: Codable, Sendable { + case integer(Int) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unreceptivity: Codable, Sendable { + case integer(Int) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unsatisfactoriness: Codable, Sendable { + case bool(Bool) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum UnstressedElement: Codable, Sendable { + case bool(Bool) + case string(String) + case unstressedClass(UnstressedClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(UnstressedClass.self) { + self = .unstressedClass(x) + return + } + throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .unstressedClass(let x): + try container.encode(x) + } + } +} + +// MARK: - UnstressedClass +final class UnstressedClass: Codable, Sendable { + let alain: JSONNull? + let amphirhina: JSONNull? + let antimachinery: JSONNull? + let coldish: JSONNull? + let crantara: JSONNull? + let distinguishing: JSONNull? + let elytroposis: JSONNull? + let gentianwort: JSONNull? + let heliosis: JSONNull? + let instrumental: JSONNull? + let introinflection: JSONNull? + let kala: JSONNull? + let lincolnian: JSONNull? + let metad: JSONNull? + let sarcophilus: JSONNull? + let swingingly: JSONNull? + let unconformity: JSONNull? + let undecreed: JSONNull? + let venerable: JSONNull? + let vowellessness: JSONNull? + + enum CodingKeys: String, CodingKey { + case alain = "Alain" + case amphirhina = "Amphirhina" + case antimachinery = "antimachinery" + case coldish = "coldish" + case crantara = "crantara" + case distinguishing = "distinguishing" + case elytroposis = "elytroposis" + case gentianwort = "gentianwort" + case heliosis = "heliosis" + case instrumental = "instrumental" + case introinflection = "introinflection" + case kala = "kala" + case lincolnian = "Lincolnian" + case metad = "metad" + case sarcophilus = "Sarcophilus" + case swingingly = "swingingly" + case unconformity = "unconformity" + case undecreed = "undecreed" + case venerable = "venerable" + case vowellessness = "vowellessness" + } + + init(alain: JSONNull?, amphirhina: JSONNull?, antimachinery: JSONNull?, coldish: JSONNull?, crantara: JSONNull?, distinguishing: JSONNull?, elytroposis: JSONNull?, gentianwort: JSONNull?, heliosis: JSONNull?, instrumental: JSONNull?, introinflection: JSONNull?, kala: JSONNull?, lincolnian: JSONNull?, metad: JSONNull?, sarcophilus: JSONNull?, swingingly: JSONNull?, unconformity: JSONNull?, undecreed: JSONNull?, venerable: JSONNull?, vowellessness: JSONNull?) { + self.alain = alain + self.amphirhina = amphirhina + self.antimachinery = antimachinery + self.coldish = coldish + self.crantara = crantara + self.distinguishing = distinguishing + self.elytroposis = elytroposis + self.gentianwort = gentianwort + self.heliosis = heliosis + self.instrumental = instrumental + self.introinflection = introinflection + self.kala = kala + self.lincolnian = lincolnian + self.metad = metad + self.sarcophilus = sarcophilus + self.swingingly = swingingly + self.unconformity = unconformity + self.undecreed = undecreed + self.venerable = venerable + self.vowellessness = vowellessness + } +} + +// MARK: UnstressedClass convenience initializers and mutators + +extension UnstressedClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(UnstressedClass.self, from: data) + self.init(alain: me.alain, amphirhina: me.amphirhina, antimachinery: me.antimachinery, coldish: me.coldish, crantara: me.crantara, distinguishing: me.distinguishing, elytroposis: me.elytroposis, gentianwort: me.gentianwort, heliosis: me.heliosis, instrumental: me.instrumental, introinflection: me.introinflection, kala: me.kala, lincolnian: me.lincolnian, metad: me.metad, sarcophilus: me.sarcophilus, swingingly: me.swingingly, unconformity: me.unconformity, undecreed: me.undecreed, venerable: me.venerable, vowellessness: me.vowellessness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alain: JSONNull?? = nil, + amphirhina: JSONNull?? = nil, + antimachinery: JSONNull?? = nil, + coldish: JSONNull?? = nil, + crantara: JSONNull?? = nil, + distinguishing: JSONNull?? = nil, + elytroposis: JSONNull?? = nil, + gentianwort: JSONNull?? = nil, + heliosis: JSONNull?? = nil, + instrumental: JSONNull?? = nil, + introinflection: JSONNull?? = nil, + kala: JSONNull?? = nil, + lincolnian: JSONNull?? = nil, + metad: JSONNull?? = nil, + sarcophilus: JSONNull?? = nil, + swingingly: JSONNull?? = nil, + unconformity: JSONNull?? = nil, + undecreed: JSONNull?? = nil, + venerable: JSONNull?? = nil, + vowellessness: JSONNull?? = nil + ) -> UnstressedClass { + return UnstressedClass( + alain: alain ?? self.alain, + amphirhina: amphirhina ?? self.amphirhina, + antimachinery: antimachinery ?? self.antimachinery, + coldish: coldish ?? self.coldish, + crantara: crantara ?? self.crantara, + distinguishing: distinguishing ?? self.distinguishing, + elytroposis: elytroposis ?? self.elytroposis, + gentianwort: gentianwort ?? self.gentianwort, + heliosis: heliosis ?? self.heliosis, + instrumental: instrumental ?? self.instrumental, + introinflection: introinflection ?? self.introinflection, + kala: kala ?? self.kala, + lincolnian: lincolnian ?? self.lincolnian, + metad: metad ?? self.metad, + sarcophilus: sarcophilus ?? self.sarcophilus, + swingingly: swingingly ?? self.swingingly, + unconformity: unconformity ?? self.unconformity, + undecreed: undecreed ?? self.undecreed, + venerable: venerable ?? self.venerable, + vowellessness: vowellessness ?? self.vowellessness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Untasked: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unvarying: Codable, Sendable { + case bool(Bool) + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Vehemently: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Whitepot: Codable, Sendable { + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum WrothyElement: Codable, Sendable { + case nullArray([JSONNull?]) + case wrothyClass(WrothyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(WrothyClass.self) { + self = .wrothyClass(x) + return + } + throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .wrothyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - WrothyClass +final class WrothyClass: Codable, Sendable { + let aeschynanthus: JSONNull? + let aquiferous: JSONNull? + let cheapener: JSONNull? + let enumeration: JSONNull? + let ephesine: JSONNull? + let escadrille: JSONNull? + let estrous: JSONNull? + let interestedly: JSONNull? + let katakinetomer: JSONNull? + let mortification: JSONNull? + let morula: JSONNull? + let orthosymmetrical: JSONNull? + let overbark: JSONNull? + let politist: JSONNull? + let qualified: JSONNull? + let sphenomalar: JSONNull? + let throatful: JSONNull? + let transhumance: JSONNull? + let triandrian: JSONNull? + let unbooked: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeschynanthus = "Aeschynanthus" + case aquiferous = "aquiferous" + case cheapener = "cheapener" + case enumeration = "enumeration" + case ephesine = "Ephesine" + case escadrille = "escadrille" + case estrous = "estrous" + case interestedly = "interestedly" + case katakinetomer = "katakinetomer" + case mortification = "mortification" + case morula = "morula" + case orthosymmetrical = "orthosymmetrical" + case overbark = "overbark" + case politist = "politist" + case qualified = "qualified" + case sphenomalar = "sphenomalar" + case throatful = "throatful" + case transhumance = "transhumance" + case triandrian = "triandrian" + case unbooked = "unbooked" + } + + init(aeschynanthus: JSONNull?, aquiferous: JSONNull?, cheapener: JSONNull?, enumeration: JSONNull?, ephesine: JSONNull?, escadrille: JSONNull?, estrous: JSONNull?, interestedly: JSONNull?, katakinetomer: JSONNull?, mortification: JSONNull?, morula: JSONNull?, orthosymmetrical: JSONNull?, overbark: JSONNull?, politist: JSONNull?, qualified: JSONNull?, sphenomalar: JSONNull?, throatful: JSONNull?, transhumance: JSONNull?, triandrian: JSONNull?, unbooked: JSONNull?) { + self.aeschynanthus = aeschynanthus + self.aquiferous = aquiferous + self.cheapener = cheapener + self.enumeration = enumeration + self.ephesine = ephesine + self.escadrille = escadrille + self.estrous = estrous + self.interestedly = interestedly + self.katakinetomer = katakinetomer + self.mortification = mortification + self.morula = morula + self.orthosymmetrical = orthosymmetrical + self.overbark = overbark + self.politist = politist + self.qualified = qualified + self.sphenomalar = sphenomalar + self.throatful = throatful + self.transhumance = transhumance + self.triandrian = triandrian + self.unbooked = unbooked + } +} + +// MARK: WrothyClass convenience initializers and mutators + +extension WrothyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(WrothyClass.self, from: data) + self.init(aeschynanthus: me.aeschynanthus, aquiferous: me.aquiferous, cheapener: me.cheapener, enumeration: me.enumeration, ephesine: me.ephesine, escadrille: me.escadrille, estrous: me.estrous, interestedly: me.interestedly, katakinetomer: me.katakinetomer, mortification: me.mortification, morula: me.morula, orthosymmetrical: me.orthosymmetrical, overbark: me.overbark, politist: me.politist, qualified: me.qualified, sphenomalar: me.sphenomalar, throatful: me.throatful, transhumance: me.transhumance, triandrian: me.triandrian, unbooked: me.unbooked) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeschynanthus: JSONNull?? = nil, + aquiferous: JSONNull?? = nil, + cheapener: JSONNull?? = nil, + enumeration: JSONNull?? = nil, + ephesine: JSONNull?? = nil, + escadrille: JSONNull?? = nil, + estrous: JSONNull?? = nil, + interestedly: JSONNull?? = nil, + katakinetomer: JSONNull?? = nil, + mortification: JSONNull?? = nil, + morula: JSONNull?? = nil, + orthosymmetrical: JSONNull?? = nil, + overbark: JSONNull?? = nil, + politist: JSONNull?? = nil, + qualified: JSONNull?? = nil, + sphenomalar: JSONNull?? = nil, + throatful: JSONNull?? = nil, + transhumance: JSONNull?? = nil, + triandrian: JSONNull?? = nil, + unbooked: JSONNull?? = nil + ) -> WrothyClass { + return WrothyClass( + aeschynanthus: aeschynanthus ?? self.aeschynanthus, + aquiferous: aquiferous ?? self.aquiferous, + cheapener: cheapener ?? self.cheapener, + enumeration: enumeration ?? self.enumeration, + ephesine: ephesine ?? self.ephesine, + escadrille: escadrille ?? self.escadrille, + estrous: estrous ?? self.estrous, + interestedly: interestedly ?? self.interestedly, + katakinetomer: katakinetomer ?? self.katakinetomer, + mortification: mortification ?? self.mortification, + morula: morula ?? self.morula, + orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical, + overbark: overbark ?? self.overbark, + politist: politist ?? self.politist, + qualified: qualified ?? self.qualified, + sphenomalar: sphenomalar ?? self.sphenomalar, + throatful: throatful ?? self.throatful, + transhumance: transhumance ?? self.transhumance, + triandrian: triandrian ?? self.triandrian, + unbooked: unbooked ?? self.unbooked + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift-sendable-objective-c/test/inputs/json/priority/combinations1.json/default/quicktype.swift b/head/swift-sendable-objective-c/test/inputs/json/priority/combinations1.json/default/quicktype.swift new file mode 100644 index 0000000..78d4089 --- /dev/null +++ b/head/swift-sendable-objective-c/test/inputs/json/priority/combinations1.json/default/quicktype.swift @@ -0,0 +1,3178 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +@objcMembers final class TopLevel: NSObject, Codable, Sendable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [Jacutinga] + + enum CodingKeys: String, CodingKey { + case centrodesmose = "centrodesmose" + case cerograph = "cerograph" + case chemotherapeutics = "chemotherapeutics" + case cimelia = "cimelia" + case citrated = "citrated" + case clinodome = "clinodome" + case coadjust = "coadjust" + case consilience = "consilience" + case constructor = "constructor" + case continuative = "continuative" + case credulity = "credulity" + case creviced = "creviced" + case cubiculum = "cubiculum" + case deruralize = "deruralize" + case diaereses = "diaereses" + case dissolution = "dissolution" + case downstroke = "downstroke" + case electrotautomerism = "electrotautomerism" + case eleutheromania = "eleutheromania" + case encrust = "encrust" + case entomoid = "entomoid" + case epipaleolithic = "epipaleolithic" + case expropriable = "expropriable" + case faggingly = "faggingly" + case fenks = "fenks" + case flagmaking = "flagmaking" + case fluorometer = "fluorometer" + case fulsome = "fulsome" + case fuzzy = "fuzzy" + case gardenwards = "gardenwards" + case generalissimo = "generalissimo" + case habeas = "habeas" + case hemicrystalline = "hemicrystalline" + case hemocoele = "hemocoele" + case hoister = "hoister" + case hyperpiesis = "hyperpiesis" + case hyppish = "hyppish" + case idealizer = "idealizer" + case incrustator = "incrustator" + case intentiveness = "intentiveness" + case interacinar = "interacinar" + case intercorrelation = "intercorrelation" + case jacutinga = "jacutinga" + } + + init(centrodesmose: String, cerograph: [CerographElement], chemotherapeutics: [ChemotherapeuticElement], cimelia: [CimeliaElement], citrated: Int, clinodome: [Clinodome], coadjust: [CoadjustElement], consilience: [Consilience], constructor: [Constructor], continuative: [Continuative], credulity: [CredulityElement], creviced: [Creviced], cubiculum: [[Int?]], deruralize: [DeruralizeElement], diaereses: [DiaereseElement], dissolution: [[JSONNull?]?], downstroke: [Downstroke], electrotautomerism: [Double?], eleutheromania: [Eleutheromania], encrust: Encrust, entomoid: [Entomoid], epipaleolithic: [Epipaleolithic], expropriable: [Expropriable], faggingly: [FagginglyElement], fenks: [FenkElement], flagmaking: [FlagmakingElement], fluorometer: [Fluorometer], fulsome: [Int?], fuzzy: [Fuzzy], gardenwards: [Gardenward], generalissimo: [Generalissimo], habeas: [[String: Int]?], hemicrystalline: [Hemicrystalline], hemocoele: [HemocoeleElement], hoister: [Hoister], hyperpiesis: [Hyperpiesi], hyppish: [Hyppish], idealizer: [Idealizer], incrustator: [Incrustator], intentiveness: [Intentiveness], interacinar: Interacinar, intercorrelation: [[Int]?], jacutinga: [Jacutinga]) { + self.centrodesmose = centrodesmose + self.cerograph = cerograph + self.chemotherapeutics = chemotherapeutics + self.cimelia = cimelia + self.citrated = citrated + self.clinodome = clinodome + self.coadjust = coadjust + self.consilience = consilience + self.constructor = constructor + self.continuative = continuative + self.credulity = credulity + self.creviced = creviced + self.cubiculum = cubiculum + self.deruralize = deruralize + self.diaereses = diaereses + self.dissolution = dissolution + self.downstroke = downstroke + self.electrotautomerism = electrotautomerism + self.eleutheromania = eleutheromania + self.encrust = encrust + self.entomoid = entomoid + self.epipaleolithic = epipaleolithic + self.expropriable = expropriable + self.faggingly = faggingly + self.fenks = fenks + self.flagmaking = flagmaking + self.fluorometer = fluorometer + self.fulsome = fulsome + self.fuzzy = fuzzy + self.gardenwards = gardenwards + self.generalissimo = generalissimo + self.habeas = habeas + self.hemicrystalline = hemicrystalline + self.hemocoele = hemocoele + self.hoister = hoister + self.hyperpiesis = hyperpiesis + self.hyppish = hyppish + self.idealizer = idealizer + self.incrustator = incrustator + self.intentiveness = intentiveness + self.interacinar = interacinar + self.intercorrelation = intercorrelation + self.jacutinga = jacutinga + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(centrodesmose: me.centrodesmose, cerograph: me.cerograph, chemotherapeutics: me.chemotherapeutics, cimelia: me.cimelia, citrated: me.citrated, clinodome: me.clinodome, coadjust: me.coadjust, consilience: me.consilience, constructor: me.constructor, continuative: me.continuative, credulity: me.credulity, creviced: me.creviced, cubiculum: me.cubiculum, deruralize: me.deruralize, diaereses: me.diaereses, dissolution: me.dissolution, downstroke: me.downstroke, electrotautomerism: me.electrotautomerism, eleutheromania: me.eleutheromania, encrust: me.encrust, entomoid: me.entomoid, epipaleolithic: me.epipaleolithic, expropriable: me.expropriable, faggingly: me.faggingly, fenks: me.fenks, flagmaking: me.flagmaking, fluorometer: me.fluorometer, fulsome: me.fulsome, fuzzy: me.fuzzy, gardenwards: me.gardenwards, generalissimo: me.generalissimo, habeas: me.habeas, hemicrystalline: me.hemicrystalline, hemocoele: me.hemocoele, hoister: me.hoister, hyperpiesis: me.hyperpiesis, hyppish: me.hyppish, idealizer: me.idealizer, incrustator: me.incrustator, intentiveness: me.intentiveness, interacinar: me.interacinar, intercorrelation: me.intercorrelation, jacutinga: me.jacutinga) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [Jacutinga]? = nil + ) -> TopLevel { + return TopLevel( + centrodesmose: centrodesmose ?? self.centrodesmose, + cerograph: cerograph ?? self.cerograph, + chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics, + cimelia: cimelia ?? self.cimelia, + citrated: citrated ?? self.citrated, + clinodome: clinodome ?? self.clinodome, + coadjust: coadjust ?? self.coadjust, + consilience: consilience ?? self.consilience, + constructor: constructor ?? self.constructor, + continuative: continuative ?? self.continuative, + credulity: credulity ?? self.credulity, + creviced: creviced ?? self.creviced, + cubiculum: cubiculum ?? self.cubiculum, + deruralize: deruralize ?? self.deruralize, + diaereses: diaereses ?? self.diaereses, + dissolution: dissolution ?? self.dissolution, + downstroke: downstroke ?? self.downstroke, + electrotautomerism: electrotautomerism ?? self.electrotautomerism, + eleutheromania: eleutheromania ?? self.eleutheromania, + encrust: encrust ?? self.encrust, + entomoid: entomoid ?? self.entomoid, + epipaleolithic: epipaleolithic ?? self.epipaleolithic, + expropriable: expropriable ?? self.expropriable, + faggingly: faggingly ?? self.faggingly, + fenks: fenks ?? self.fenks, + flagmaking: flagmaking ?? self.flagmaking, + fluorometer: fluorometer ?? self.fluorometer, + fulsome: fulsome ?? self.fulsome, + fuzzy: fuzzy ?? self.fuzzy, + gardenwards: gardenwards ?? self.gardenwards, + generalissimo: generalissimo ?? self.generalissimo, + habeas: habeas ?? self.habeas, + hemicrystalline: hemicrystalline ?? self.hemicrystalline, + hemocoele: hemocoele ?? self.hemocoele, + hoister: hoister ?? self.hoister, + hyperpiesis: hyperpiesis ?? self.hyperpiesis, + hyppish: hyppish ?? self.hyppish, + idealizer: idealizer ?? self.idealizer, + incrustator: incrustator ?? self.incrustator, + intentiveness: intentiveness ?? self.intentiveness, + interacinar: interacinar ?? self.interacinar, + intercorrelation: intercorrelation ?? self.intercorrelation, + jacutinga: jacutinga ?? self.jacutinga + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable, Sendable { + case cerographClass(CerographClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CerographClass.self) { + self = .cerographClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cerographClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CerographClass +@objcMembers final class CerographClass: NSObject, Codable, Sendable { + let apotropaion: JSONNull? + let casuary: JSONNull? + let creaker: JSONNull? + let disqualification: JSONNull? + let imperatorious: JSONNull? + let impermeabilize: JSONNull? + let metastoma: JSONNull? + let noctidiurnal: JSONNull? + let nonreserve: JSONNull? + let ophthalmotonometry: JSONNull? + let pailful: JSONNull? + let pigfish: JSONNull? + let pongee: JSONNull? + let prosodical: JSONNull? + let scrofuloderm: JSONNull? + let storekeeping: JSONNull? + let therologist: JSONNull? + let tolowa: JSONNull? + let tradeful: JSONNull? + let unriveting: JSONNull? + + enum CodingKeys: String, CodingKey { + case apotropaion = "apotropaion" + case casuary = "casuary" + case creaker = "creaker" + case disqualification = "disqualification" + case imperatorious = "imperatorious" + case impermeabilize = "impermeabilize" + case metastoma = "metastoma" + case noctidiurnal = "noctidiurnal" + case nonreserve = "nonreserve" + case ophthalmotonometry = "ophthalmotonometry" + case pailful = "pailful" + case pigfish = "pigfish" + case pongee = "pongee" + case prosodical = "prosodical" + case scrofuloderm = "scrofuloderm" + case storekeeping = "storekeeping" + case therologist = "therologist" + case tolowa = "Tolowa" + case tradeful = "tradeful" + case unriveting = "unriveting" + } + + init(apotropaion: JSONNull?, casuary: JSONNull?, creaker: JSONNull?, disqualification: JSONNull?, imperatorious: JSONNull?, impermeabilize: JSONNull?, metastoma: JSONNull?, noctidiurnal: JSONNull?, nonreserve: JSONNull?, ophthalmotonometry: JSONNull?, pailful: JSONNull?, pigfish: JSONNull?, pongee: JSONNull?, prosodical: JSONNull?, scrofuloderm: JSONNull?, storekeeping: JSONNull?, therologist: JSONNull?, tolowa: JSONNull?, tradeful: JSONNull?, unriveting: JSONNull?) { + self.apotropaion = apotropaion + self.casuary = casuary + self.creaker = creaker + self.disqualification = disqualification + self.imperatorious = imperatorious + self.impermeabilize = impermeabilize + self.metastoma = metastoma + self.noctidiurnal = noctidiurnal + self.nonreserve = nonreserve + self.ophthalmotonometry = ophthalmotonometry + self.pailful = pailful + self.pigfish = pigfish + self.pongee = pongee + self.prosodical = prosodical + self.scrofuloderm = scrofuloderm + self.storekeeping = storekeeping + self.therologist = therologist + self.tolowa = tolowa + self.tradeful = tradeful + self.unriveting = unriveting + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CerographClass.self, from: data) + self.init(apotropaion: me.apotropaion, casuary: me.casuary, creaker: me.creaker, disqualification: me.disqualification, imperatorious: me.imperatorious, impermeabilize: me.impermeabilize, metastoma: me.metastoma, noctidiurnal: me.noctidiurnal, nonreserve: me.nonreserve, ophthalmotonometry: me.ophthalmotonometry, pailful: me.pailful, pigfish: me.pigfish, pongee: me.pongee, prosodical: me.prosodical, scrofuloderm: me.scrofuloderm, storekeeping: me.storekeeping, therologist: me.therologist, tolowa: me.tolowa, tradeful: me.tradeful, unriveting: me.unriveting) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apotropaion: JSONNull?? = nil, + casuary: JSONNull?? = nil, + creaker: JSONNull?? = nil, + disqualification: JSONNull?? = nil, + imperatorious: JSONNull?? = nil, + impermeabilize: JSONNull?? = nil, + metastoma: JSONNull?? = nil, + noctidiurnal: JSONNull?? = nil, + nonreserve: JSONNull?? = nil, + ophthalmotonometry: JSONNull?? = nil, + pailful: JSONNull?? = nil, + pigfish: JSONNull?? = nil, + pongee: JSONNull?? = nil, + prosodical: JSONNull?? = nil, + scrofuloderm: JSONNull?? = nil, + storekeeping: JSONNull?? = nil, + therologist: JSONNull?? = nil, + tolowa: JSONNull?? = nil, + tradeful: JSONNull?? = nil, + unriveting: JSONNull?? = nil + ) -> CerographClass { + return CerographClass( + apotropaion: apotropaion ?? self.apotropaion, + casuary: casuary ?? self.casuary, + creaker: creaker ?? self.creaker, + disqualification: disqualification ?? self.disqualification, + imperatorious: imperatorious ?? self.imperatorious, + impermeabilize: impermeabilize ?? self.impermeabilize, + metastoma: metastoma ?? self.metastoma, + noctidiurnal: noctidiurnal ?? self.noctidiurnal, + nonreserve: nonreserve ?? self.nonreserve, + ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry, + pailful: pailful ?? self.pailful, + pigfish: pigfish ?? self.pigfish, + pongee: pongee ?? self.pongee, + prosodical: prosodical ?? self.prosodical, + scrofuloderm: scrofuloderm ?? self.scrofuloderm, + storekeeping: storekeeping ?? self.storekeeping, + therologist: therologist ?? self.therologist, + tolowa: tolowa ?? self.tolowa, + tradeful: tradeful ?? self.tradeful, + unriveting: unriveting ?? self.unriveting + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable, Sendable { + case chemotherapeuticClass(ChemotherapeuticClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(ChemotherapeuticClass.self) { + self = .chemotherapeuticClass(x) + return + } + throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .chemotherapeuticClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +// MARK: - ChemotherapeuticClass +@objcMembers final class ChemotherapeuticClass: NSObject, Codable, Sendable { + let angioneurotic: JSONNull? + let availment: JSONNull? + let bladelet: JSONNull? + let catharticalness: Double? + let caulis: JSONNull? + let chalcus: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let enteradenological: JSONNull? + let homocerc: Bool? + let imporosity: JSONNull? + let insistently: JSONNull? + let intraparietal: JSONNull? + let ivied: JSONNull? + let maureen: JSONNull? + let nonbookish: JSONNull? + let nostochine: JSONNull? + let nutcracker: JSONNull? + let ofttimes: JSONNull? + let phenocryst: JSONNull? + let precoincident: JSONNull? + let ramiferous: JSONNull? + let stagmometer: JSONNull? + let tetherball: JSONNull? + let unshy: JSONNull? + + enum CodingKeys: String, CodingKey { + case angioneurotic = "angioneurotic" + case availment = "availment" + case bladelet = "bladelet" + case catharticalness = "catharticalness" + case caulis = "caulis" + case chalcus = "chalcus" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case enteradenological = "enteradenological" + case homocerc = "homocerc" + case imporosity = "imporosity" + case insistently = "insistently" + case intraparietal = "intraparietal" + case ivied = "ivied" + case maureen = "Maureen" + case nonbookish = "nonbookish" + case nostochine = "nostochine" + case nutcracker = "nutcracker" + case ofttimes = "ofttimes" + case phenocryst = "phenocryst" + case precoincident = "precoincident" + case ramiferous = "ramiferous" + case stagmometer = "stagmometer" + case tetherball = "tetherball" + case unshy = "unshy" + } + + init(angioneurotic: JSONNull?, availment: JSONNull?, bladelet: JSONNull?, catharticalness: Double?, caulis: JSONNull?, chalcus: JSONNull?, chirotherium: Int?, disdiapason: String?, enteradenological: JSONNull?, homocerc: Bool?, imporosity: JSONNull?, insistently: JSONNull?, intraparietal: JSONNull?, ivied: JSONNull?, maureen: JSONNull?, nonbookish: JSONNull?, nostochine: JSONNull?, nutcracker: JSONNull?, ofttimes: JSONNull?, phenocryst: JSONNull?, precoincident: JSONNull?, ramiferous: JSONNull?, stagmometer: JSONNull?, tetherball: JSONNull?, unshy: JSONNull?) { + self.angioneurotic = angioneurotic + self.availment = availment + self.bladelet = bladelet + self.catharticalness = catharticalness + self.caulis = caulis + self.chalcus = chalcus + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.enteradenological = enteradenological + self.homocerc = homocerc + self.imporosity = imporosity + self.insistently = insistently + self.intraparietal = intraparietal + self.ivied = ivied + self.maureen = maureen + self.nonbookish = nonbookish + self.nostochine = nostochine + self.nutcracker = nutcracker + self.ofttimes = ofttimes + self.phenocryst = phenocryst + self.precoincident = precoincident + self.ramiferous = ramiferous + self.stagmometer = stagmometer + self.tetherball = tetherball + self.unshy = unshy + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data) + self.init(angioneurotic: me.angioneurotic, availment: me.availment, bladelet: me.bladelet, catharticalness: me.catharticalness, caulis: me.caulis, chalcus: me.chalcus, chirotherium: me.chirotherium, disdiapason: me.disdiapason, enteradenological: me.enteradenological, homocerc: me.homocerc, imporosity: me.imporosity, insistently: me.insistently, intraparietal: me.intraparietal, ivied: me.ivied, maureen: me.maureen, nonbookish: me.nonbookish, nostochine: me.nostochine, nutcracker: me.nutcracker, ofttimes: me.ofttimes, phenocryst: me.phenocryst, precoincident: me.precoincident, ramiferous: me.ramiferous, stagmometer: me.stagmometer, tetherball: me.tetherball, unshy: me.unshy) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + angioneurotic: JSONNull?? = nil, + availment: JSONNull?? = nil, + bladelet: JSONNull?? = nil, + catharticalness: Double?? = nil, + caulis: JSONNull?? = nil, + chalcus: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + enteradenological: JSONNull?? = nil, + homocerc: Bool?? = nil, + imporosity: JSONNull?? = nil, + insistently: JSONNull?? = nil, + intraparietal: JSONNull?? = nil, + ivied: JSONNull?? = nil, + maureen: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nostochine: JSONNull?? = nil, + nutcracker: JSONNull?? = nil, + ofttimes: JSONNull?? = nil, + phenocryst: JSONNull?? = nil, + precoincident: JSONNull?? = nil, + ramiferous: JSONNull?? = nil, + stagmometer: JSONNull?? = nil, + tetherball: JSONNull?? = nil, + unshy: JSONNull?? = nil + ) -> ChemotherapeuticClass { + return ChemotherapeuticClass( + angioneurotic: angioneurotic ?? self.angioneurotic, + availment: availment ?? self.availment, + bladelet: bladelet ?? self.bladelet, + catharticalness: catharticalness ?? self.catharticalness, + caulis: caulis ?? self.caulis, + chalcus: chalcus ?? self.chalcus, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + enteradenological: enteradenological ?? self.enteradenological, + homocerc: homocerc ?? self.homocerc, + imporosity: imporosity ?? self.imporosity, + insistently: insistently ?? self.insistently, + intraparietal: intraparietal ?? self.intraparietal, + ivied: ivied ?? self.ivied, + maureen: maureen ?? self.maureen, + nonbookish: nonbookish ?? self.nonbookish, + nostochine: nostochine ?? self.nostochine, + nutcracker: nutcracker ?? self.nutcracker, + ofttimes: ofttimes ?? self.ofttimes, + phenocryst: phenocryst ?? self.phenocryst, + precoincident: precoincident ?? self.precoincident, + ramiferous: ramiferous ?? self.ramiferous, + stagmometer: stagmometer ?? self.stagmometer, + tetherball: tetherball ?? self.tetherball, + unshy: unshy ?? self.unshy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CimeliaClass +@objcMembers final class CimeliaClass: NSObject, Codable, Sendable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CimeliaClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> CimeliaClass { + return CimeliaClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Clinodome: Codable, Sendable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CoadjustElement: Codable, Sendable { + case coadjustClass(CoadjustClass) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CoadjustClass.self) { + self = .coadjustClass(x) + return + } + throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .coadjustClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +// MARK: - CoadjustClass +@objcMembers final class CoadjustClass: NSObject, Codable, Sendable { + let amidosulphonal: JSONNull? + let benny: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ensnare: JSONNull? + let homocerc: Bool? + let hybridizer: JSONNull? + let leastwise: JSONNull? + let lof: JSONNull? + let monkhood: JSONNull? + let netherlandish: JSONNull? + let nonbookish: JSONNull? + let peonism: JSONNull? + let phonelescope: JSONNull? + let porphyrogeniture: JSONNull? + let preindemnify: JSONNull? + let rosal: JSONNull? + let scalenous: JSONNull? + let scopine: JSONNull? + let sedaceae: JSONNull? + let suberinize: JSONNull? + let symbiot: JSONNull? + let tablefellow: JSONNull? + let unchargeable: JSONNull? + + enum CodingKeys: String, CodingKey { + case amidosulphonal = "amidosulphonal" + case benny = "Benny" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ensnare = "ensnare" + case homocerc = "homocerc" + case hybridizer = "hybridizer" + case leastwise = "leastwise" + case lof = "lof" + case monkhood = "monkhood" + case netherlandish = "Netherlandish" + case nonbookish = "nonbookish" + case peonism = "peonism" + case phonelescope = "Phonelescope" + case porphyrogeniture = "porphyrogeniture" + case preindemnify = "preindemnify" + case rosal = "rosal" + case scalenous = "scalenous" + case scopine = "scopine" + case sedaceae = "Sedaceae" + case suberinize = "suberinize" + case symbiot = "symbiot" + case tablefellow = "tablefellow" + case unchargeable = "unchargeable" + } + + init(amidosulphonal: JSONNull?, benny: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ensnare: JSONNull?, homocerc: Bool?, hybridizer: JSONNull?, leastwise: JSONNull?, lof: JSONNull?, monkhood: JSONNull?, netherlandish: JSONNull?, nonbookish: JSONNull?, peonism: JSONNull?, phonelescope: JSONNull?, porphyrogeniture: JSONNull?, preindemnify: JSONNull?, rosal: JSONNull?, scalenous: JSONNull?, scopine: JSONNull?, sedaceae: JSONNull?, suberinize: JSONNull?, symbiot: JSONNull?, tablefellow: JSONNull?, unchargeable: JSONNull?) { + self.amidosulphonal = amidosulphonal + self.benny = benny + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ensnare = ensnare + self.homocerc = homocerc + self.hybridizer = hybridizer + self.leastwise = leastwise + self.lof = lof + self.monkhood = monkhood + self.netherlandish = netherlandish + self.nonbookish = nonbookish + self.peonism = peonism + self.phonelescope = phonelescope + self.porphyrogeniture = porphyrogeniture + self.preindemnify = preindemnify + self.rosal = rosal + self.scalenous = scalenous + self.scopine = scopine + self.sedaceae = sedaceae + self.suberinize = suberinize + self.symbiot = symbiot + self.tablefellow = tablefellow + self.unchargeable = unchargeable + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CoadjustClass.self, from: data) + self.init(amidosulphonal: me.amidosulphonal, benny: me.benny, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ensnare: me.ensnare, homocerc: me.homocerc, hybridizer: me.hybridizer, leastwise: me.leastwise, lof: me.lof, monkhood: me.monkhood, netherlandish: me.netherlandish, nonbookish: me.nonbookish, peonism: me.peonism, phonelescope: me.phonelescope, porphyrogeniture: me.porphyrogeniture, preindemnify: me.preindemnify, rosal: me.rosal, scalenous: me.scalenous, scopine: me.scopine, sedaceae: me.sedaceae, suberinize: me.suberinize, symbiot: me.symbiot, tablefellow: me.tablefellow, unchargeable: me.unchargeable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amidosulphonal: JSONNull?? = nil, + benny: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ensnare: JSONNull?? = nil, + homocerc: Bool?? = nil, + hybridizer: JSONNull?? = nil, + leastwise: JSONNull?? = nil, + lof: JSONNull?? = nil, + monkhood: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + peonism: JSONNull?? = nil, + phonelescope: JSONNull?? = nil, + porphyrogeniture: JSONNull?? = nil, + preindemnify: JSONNull?? = nil, + rosal: JSONNull?? = nil, + scalenous: JSONNull?? = nil, + scopine: JSONNull?? = nil, + sedaceae: JSONNull?? = nil, + suberinize: JSONNull?? = nil, + symbiot: JSONNull?? = nil, + tablefellow: JSONNull?? = nil, + unchargeable: JSONNull?? = nil + ) -> CoadjustClass { + return CoadjustClass( + amidosulphonal: amidosulphonal ?? self.amidosulphonal, + benny: benny ?? self.benny, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ensnare: ensnare ?? self.ensnare, + homocerc: homocerc ?? self.homocerc, + hybridizer: hybridizer ?? self.hybridizer, + leastwise: leastwise ?? self.leastwise, + lof: lof ?? self.lof, + monkhood: monkhood ?? self.monkhood, + netherlandish: netherlandish ?? self.netherlandish, + nonbookish: nonbookish ?? self.nonbookish, + peonism: peonism ?? self.peonism, + phonelescope: phonelescope ?? self.phonelescope, + porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture, + preindemnify: preindemnify ?? self.preindemnify, + rosal: rosal ?? self.rosal, + scalenous: scalenous ?? self.scalenous, + scopine: scopine ?? self.scopine, + sedaceae: sedaceae ?? self.sedaceae, + suberinize: suberinize ?? self.suberinize, + symbiot: symbiot ?? self.symbiot, + tablefellow: tablefellow ?? self.tablefellow, + unchargeable: unchargeable ?? self.unchargeable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Consilience: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Constructor: Codable, Sendable { + case bool(Bool) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Continuative: Codable, Sendable { + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CredulityElement: Codable, Sendable { + case credulityClass(CredulityClass) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CredulityClass.self) { + self = .credulityClass(x) + return + } + throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .credulityClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - CredulityClass +@objcMembers final class CredulityClass: NSObject, Codable, Sendable { + let ammonolytic: JSONNull? + let bushmaster: JSONNull? + let considering: JSONNull? + let consuetudinary: JSONNull? + let embarras: JSONNull? + let fineness: JSONNull? + let flaithship: JSONNull? + let flavia: JSONNull? + let gruffly: JSONNull? + let hedychium: JSONNull? + let leadwort: JSONNull? + let overseriously: JSONNull? + let parabola: JSONNull? + let pectinatodenticulate: JSONNull? + let popean: JSONNull? + let pornocrat: JSONNull? + let quadrisect: JSONNull? + let seriality: JSONNull? + let vamphorn: JSONNull? + let wharp: JSONNull? + + enum CodingKeys: String, CodingKey { + case ammonolytic = "ammonolytic" + case bushmaster = "bushmaster" + case considering = "considering" + case consuetudinary = "consuetudinary" + case embarras = "embarras" + case fineness = "fineness" + case flaithship = "flaithship" + case flavia = "Flavia" + case gruffly = "gruffly" + case hedychium = "Hedychium" + case leadwort = "leadwort" + case overseriously = "overseriously" + case parabola = "parabola" + case pectinatodenticulate = "pectinatodenticulate" + case popean = "Popean" + case pornocrat = "pornocrat" + case quadrisect = "quadrisect" + case seriality = "seriality" + case vamphorn = "vamphorn" + case wharp = "wharp" + } + + init(ammonolytic: JSONNull?, bushmaster: JSONNull?, considering: JSONNull?, consuetudinary: JSONNull?, embarras: JSONNull?, fineness: JSONNull?, flaithship: JSONNull?, flavia: JSONNull?, gruffly: JSONNull?, hedychium: JSONNull?, leadwort: JSONNull?, overseriously: JSONNull?, parabola: JSONNull?, pectinatodenticulate: JSONNull?, popean: JSONNull?, pornocrat: JSONNull?, quadrisect: JSONNull?, seriality: JSONNull?, vamphorn: JSONNull?, wharp: JSONNull?) { + self.ammonolytic = ammonolytic + self.bushmaster = bushmaster + self.considering = considering + self.consuetudinary = consuetudinary + self.embarras = embarras + self.fineness = fineness + self.flaithship = flaithship + self.flavia = flavia + self.gruffly = gruffly + self.hedychium = hedychium + self.leadwort = leadwort + self.overseriously = overseriously + self.parabola = parabola + self.pectinatodenticulate = pectinatodenticulate + self.popean = popean + self.pornocrat = pornocrat + self.quadrisect = quadrisect + self.seriality = seriality + self.vamphorn = vamphorn + self.wharp = wharp + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CredulityClass.self, from: data) + self.init(ammonolytic: me.ammonolytic, bushmaster: me.bushmaster, considering: me.considering, consuetudinary: me.consuetudinary, embarras: me.embarras, fineness: me.fineness, flaithship: me.flaithship, flavia: me.flavia, gruffly: me.gruffly, hedychium: me.hedychium, leadwort: me.leadwort, overseriously: me.overseriously, parabola: me.parabola, pectinatodenticulate: me.pectinatodenticulate, popean: me.popean, pornocrat: me.pornocrat, quadrisect: me.quadrisect, seriality: me.seriality, vamphorn: me.vamphorn, wharp: me.wharp) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + ammonolytic: JSONNull?? = nil, + bushmaster: JSONNull?? = nil, + considering: JSONNull?? = nil, + consuetudinary: JSONNull?? = nil, + embarras: JSONNull?? = nil, + fineness: JSONNull?? = nil, + flaithship: JSONNull?? = nil, + flavia: JSONNull?? = nil, + gruffly: JSONNull?? = nil, + hedychium: JSONNull?? = nil, + leadwort: JSONNull?? = nil, + overseriously: JSONNull?? = nil, + parabola: JSONNull?? = nil, + pectinatodenticulate: JSONNull?? = nil, + popean: JSONNull?? = nil, + pornocrat: JSONNull?? = nil, + quadrisect: JSONNull?? = nil, + seriality: JSONNull?? = nil, + vamphorn: JSONNull?? = nil, + wharp: JSONNull?? = nil + ) -> CredulityClass { + return CredulityClass( + ammonolytic: ammonolytic ?? self.ammonolytic, + bushmaster: bushmaster ?? self.bushmaster, + considering: considering ?? self.considering, + consuetudinary: consuetudinary ?? self.consuetudinary, + embarras: embarras ?? self.embarras, + fineness: fineness ?? self.fineness, + flaithship: flaithship ?? self.flaithship, + flavia: flavia ?? self.flavia, + gruffly: gruffly ?? self.gruffly, + hedychium: hedychium ?? self.hedychium, + leadwort: leadwort ?? self.leadwort, + overseriously: overseriously ?? self.overseriously, + parabola: parabola ?? self.parabola, + pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate, + popean: popean ?? self.popean, + pornocrat: pornocrat ?? self.pornocrat, + quadrisect: quadrisect ?? self.quadrisect, + seriality: seriality ?? self.seriality, + vamphorn: vamphorn ?? self.vamphorn, + wharp: wharp ?? self.wharp + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Creviced: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum DeruralizeElement: Codable, Sendable { + case bool(Bool) + case deruralizeClass(DeruralizeClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(DeruralizeClass.self) { + self = .deruralizeClass(x) + return + } + throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .deruralizeClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DeruralizeClass +@objcMembers final class DeruralizeClass: NSObject, Codable, Sendable { + let bockerel: JSONNull? + let boulder: JSONNull? + let churrus: JSONNull? + let counterdigged: JSONNull? + let dialogite: JSONNull? + let digenic: JSONNull? + let dunbird: JSONNull? + let ergatogyne: JSONNull? + let fiendful: JSONNull? + let jackrod: JSONNull? + let jehovistic: JSONNull? + let paninean: JSONNull? + let panther: JSONNull? + let placentigerous: JSONNull? + let romney: JSONNull? + let sparm: JSONNull? + let tocsin: JSONNull? + let unnicked: JSONNull? + let unstavable: JSONNull? + let windfirm: JSONNull? + + enum CodingKeys: String, CodingKey { + case bockerel = "bockerel" + case boulder = "boulder" + case churrus = "churrus" + case counterdigged = "counterdigged" + case dialogite = "dialogite" + case digenic = "digenic" + case dunbird = "dunbird" + case ergatogyne = "ergatogyne" + case fiendful = "fiendful" + case jackrod = "jackrod" + case jehovistic = "Jehovistic" + case paninean = "Paninean" + case panther = "panther" + case placentigerous = "placentigerous" + case romney = "Romney" + case sparm = "sparm" + case tocsin = "tocsin" + case unnicked = "unnicked" + case unstavable = "unstavable" + case windfirm = "windfirm" + } + + init(bockerel: JSONNull?, boulder: JSONNull?, churrus: JSONNull?, counterdigged: JSONNull?, dialogite: JSONNull?, digenic: JSONNull?, dunbird: JSONNull?, ergatogyne: JSONNull?, fiendful: JSONNull?, jackrod: JSONNull?, jehovistic: JSONNull?, paninean: JSONNull?, panther: JSONNull?, placentigerous: JSONNull?, romney: JSONNull?, sparm: JSONNull?, tocsin: JSONNull?, unnicked: JSONNull?, unstavable: JSONNull?, windfirm: JSONNull?) { + self.bockerel = bockerel + self.boulder = boulder + self.churrus = churrus + self.counterdigged = counterdigged + self.dialogite = dialogite + self.digenic = digenic + self.dunbird = dunbird + self.ergatogyne = ergatogyne + self.fiendful = fiendful + self.jackrod = jackrod + self.jehovistic = jehovistic + self.paninean = paninean + self.panther = panther + self.placentigerous = placentigerous + self.romney = romney + self.sparm = sparm + self.tocsin = tocsin + self.unnicked = unnicked + self.unstavable = unstavable + self.windfirm = windfirm + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DeruralizeClass.self, from: data) + self.init(bockerel: me.bockerel, boulder: me.boulder, churrus: me.churrus, counterdigged: me.counterdigged, dialogite: me.dialogite, digenic: me.digenic, dunbird: me.dunbird, ergatogyne: me.ergatogyne, fiendful: me.fiendful, jackrod: me.jackrod, jehovistic: me.jehovistic, paninean: me.paninean, panther: me.panther, placentigerous: me.placentigerous, romney: me.romney, sparm: me.sparm, tocsin: me.tocsin, unnicked: me.unnicked, unstavable: me.unstavable, windfirm: me.windfirm) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bockerel: JSONNull?? = nil, + boulder: JSONNull?? = nil, + churrus: JSONNull?? = nil, + counterdigged: JSONNull?? = nil, + dialogite: JSONNull?? = nil, + digenic: JSONNull?? = nil, + dunbird: JSONNull?? = nil, + ergatogyne: JSONNull?? = nil, + fiendful: JSONNull?? = nil, + jackrod: JSONNull?? = nil, + jehovistic: JSONNull?? = nil, + paninean: JSONNull?? = nil, + panther: JSONNull?? = nil, + placentigerous: JSONNull?? = nil, + romney: JSONNull?? = nil, + sparm: JSONNull?? = nil, + tocsin: JSONNull?? = nil, + unnicked: JSONNull?? = nil, + unstavable: JSONNull?? = nil, + windfirm: JSONNull?? = nil + ) -> DeruralizeClass { + return DeruralizeClass( + bockerel: bockerel ?? self.bockerel, + boulder: boulder ?? self.boulder, + churrus: churrus ?? self.churrus, + counterdigged: counterdigged ?? self.counterdigged, + dialogite: dialogite ?? self.dialogite, + digenic: digenic ?? self.digenic, + dunbird: dunbird ?? self.dunbird, + ergatogyne: ergatogyne ?? self.ergatogyne, + fiendful: fiendful ?? self.fiendful, + jackrod: jackrod ?? self.jackrod, + jehovistic: jehovistic ?? self.jehovistic, + paninean: paninean ?? self.paninean, + panther: panther ?? self.panther, + placentigerous: placentigerous ?? self.placentigerous, + romney: romney ?? self.romney, + sparm: sparm ?? self.sparm, + tocsin: tocsin ?? self.tocsin, + unnicked: unnicked ?? self.unnicked, + unstavable: unstavable ?? self.unstavable, + windfirm: windfirm ?? self.windfirm + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable, Sendable { + case bool(Bool) + case diaereseClass(DiaereseClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiaereseClass.self) { + self = .diaereseClass(x) + return + } + throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .diaereseClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiaereseClass +@objcMembers final class DiaereseClass: NSObject, Codable, Sendable { + let amoreuxia: JSONNull? + let ani: JSONNull? + let bernicle: JSONNull? + let blackwasher: JSONNull? + let blowhard: JSONNull? + let broma: JSONNull? + let closecross: JSONNull? + let congregationalism: JSONNull? + let grayly: JSONNull? + let historically: JSONNull? + let hoast: JSONNull? + let irretentive: JSONNull? + let parcener: JSONNull? + let pedder: JSONNull? + let pseudoanatomic: JSONNull? + let rhizocarpian: JSONNull? + let samel: JSONNull? + let silker: JSONNull? + let subdentated: JSONNull? + let subobscure: JSONNull? + + enum CodingKeys: String, CodingKey { + case amoreuxia = "Amoreuxia" + case ani = "ani" + case bernicle = "bernicle" + case blackwasher = "blackwasher" + case blowhard = "blowhard" + case broma = "broma" + case closecross = "closecross" + case congregationalism = "congregationalism" + case grayly = "grayly" + case historically = "historically" + case hoast = "hoast" + case irretentive = "irretentive" + case parcener = "parcener" + case pedder = "pedder" + case pseudoanatomic = "pseudoanatomic" + case rhizocarpian = "rhizocarpian" + case samel = "samel" + case silker = "silker" + case subdentated = "subdentated" + case subobscure = "subobscure" + } + + init(amoreuxia: JSONNull?, ani: JSONNull?, bernicle: JSONNull?, blackwasher: JSONNull?, blowhard: JSONNull?, broma: JSONNull?, closecross: JSONNull?, congregationalism: JSONNull?, grayly: JSONNull?, historically: JSONNull?, hoast: JSONNull?, irretentive: JSONNull?, parcener: JSONNull?, pedder: JSONNull?, pseudoanatomic: JSONNull?, rhizocarpian: JSONNull?, samel: JSONNull?, silker: JSONNull?, subdentated: JSONNull?, subobscure: JSONNull?) { + self.amoreuxia = amoreuxia + self.ani = ani + self.bernicle = bernicle + self.blackwasher = blackwasher + self.blowhard = blowhard + self.broma = broma + self.closecross = closecross + self.congregationalism = congregationalism + self.grayly = grayly + self.historically = historically + self.hoast = hoast + self.irretentive = irretentive + self.parcener = parcener + self.pedder = pedder + self.pseudoanatomic = pseudoanatomic + self.rhizocarpian = rhizocarpian + self.samel = samel + self.silker = silker + self.subdentated = subdentated + self.subobscure = subobscure + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiaereseClass.self, from: data) + self.init(amoreuxia: me.amoreuxia, ani: me.ani, bernicle: me.bernicle, blackwasher: me.blackwasher, blowhard: me.blowhard, broma: me.broma, closecross: me.closecross, congregationalism: me.congregationalism, grayly: me.grayly, historically: me.historically, hoast: me.hoast, irretentive: me.irretentive, parcener: me.parcener, pedder: me.pedder, pseudoanatomic: me.pseudoanatomic, rhizocarpian: me.rhizocarpian, samel: me.samel, silker: me.silker, subdentated: me.subdentated, subobscure: me.subobscure) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amoreuxia: JSONNull?? = nil, + ani: JSONNull?? = nil, + bernicle: JSONNull?? = nil, + blackwasher: JSONNull?? = nil, + blowhard: JSONNull?? = nil, + broma: JSONNull?? = nil, + closecross: JSONNull?? = nil, + congregationalism: JSONNull?? = nil, + grayly: JSONNull?? = nil, + historically: JSONNull?? = nil, + hoast: JSONNull?? = nil, + irretentive: JSONNull?? = nil, + parcener: JSONNull?? = nil, + pedder: JSONNull?? = nil, + pseudoanatomic: JSONNull?? = nil, + rhizocarpian: JSONNull?? = nil, + samel: JSONNull?? = nil, + silker: JSONNull?? = nil, + subdentated: JSONNull?? = nil, + subobscure: JSONNull?? = nil + ) -> DiaereseClass { + return DiaereseClass( + amoreuxia: amoreuxia ?? self.amoreuxia, + ani: ani ?? self.ani, + bernicle: bernicle ?? self.bernicle, + blackwasher: blackwasher ?? self.blackwasher, + blowhard: blowhard ?? self.blowhard, + broma: broma ?? self.broma, + closecross: closecross ?? self.closecross, + congregationalism: congregationalism ?? self.congregationalism, + grayly: grayly ?? self.grayly, + historically: historically ?? self.historically, + hoast: hoast ?? self.hoast, + irretentive: irretentive ?? self.irretentive, + parcener: parcener ?? self.parcener, + pedder: pedder ?? self.pedder, + pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic, + rhizocarpian: rhizocarpian ?? self.rhizocarpian, + samel: samel ?? self.samel, + silker: silker ?? self.silker, + subdentated: subdentated ?? self.subdentated, + subobscure: subobscure ?? self.subobscure + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Downstroke: Codable, Sendable { + case bool(Bool) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eleutheromania: Codable, Sendable { + case double(Double) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Encrust +@objcMembers final class Encrust: NSObject, Codable, Sendable { + let comradely: JSONNull? + let diacanthous: JSONNull? + let feminineness: JSONNull? + let gossamered: JSONNull? + let hibernia: JSONNull? + let hibiscus: JSONNull? + let lepidosauria: JSONNull? + let lollingly: JSONNull? + let manager: JSONNull? + let mechanic: JSONNull? + let overminuteness: JSONNull? + let papelonne: JSONNull? + let plebification: JSONNull? + let pugmiller: JSONNull? + let recoveror: JSONNull? + let spermatoblastic: JSONNull? + let syllidae: JSONNull? + let ungyved: JSONNull? + let whirlabout: JSONNull? + let woodenware: JSONNull? + + enum CodingKeys: String, CodingKey { + case comradely = "comradely" + case diacanthous = "diacanthous" + case feminineness = "feminineness" + case gossamered = "gossamered" + case hibernia = "Hibernia" + case hibiscus = "Hibiscus" + case lepidosauria = "Lepidosauria" + case lollingly = "lollingly" + case manager = "manager" + case mechanic = "mechanic" + case overminuteness = "overminuteness" + case papelonne = "papelonne" + case plebification = "plebification" + case pugmiller = "pugmiller" + case recoveror = "recoveror" + case spermatoblastic = "spermatoblastic" + case syllidae = "Syllidae" + case ungyved = "ungyved" + case whirlabout = "whirlabout" + case woodenware = "woodenware" + } + + init(comradely: JSONNull?, diacanthous: JSONNull?, feminineness: JSONNull?, gossamered: JSONNull?, hibernia: JSONNull?, hibiscus: JSONNull?, lepidosauria: JSONNull?, lollingly: JSONNull?, manager: JSONNull?, mechanic: JSONNull?, overminuteness: JSONNull?, papelonne: JSONNull?, plebification: JSONNull?, pugmiller: JSONNull?, recoveror: JSONNull?, spermatoblastic: JSONNull?, syllidae: JSONNull?, ungyved: JSONNull?, whirlabout: JSONNull?, woodenware: JSONNull?) { + self.comradely = comradely + self.diacanthous = diacanthous + self.feminineness = feminineness + self.gossamered = gossamered + self.hibernia = hibernia + self.hibiscus = hibiscus + self.lepidosauria = lepidosauria + self.lollingly = lollingly + self.manager = manager + self.mechanic = mechanic + self.overminuteness = overminuteness + self.papelonne = papelonne + self.plebification = plebification + self.pugmiller = pugmiller + self.recoveror = recoveror + self.spermatoblastic = spermatoblastic + self.syllidae = syllidae + self.ungyved = ungyved + self.whirlabout = whirlabout + self.woodenware = woodenware + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Encrust.self, from: data) + self.init(comradely: me.comradely, diacanthous: me.diacanthous, feminineness: me.feminineness, gossamered: me.gossamered, hibernia: me.hibernia, hibiscus: me.hibiscus, lepidosauria: me.lepidosauria, lollingly: me.lollingly, manager: me.manager, mechanic: me.mechanic, overminuteness: me.overminuteness, papelonne: me.papelonne, plebification: me.plebification, pugmiller: me.pugmiller, recoveror: me.recoveror, spermatoblastic: me.spermatoblastic, syllidae: me.syllidae, ungyved: me.ungyved, whirlabout: me.whirlabout, woodenware: me.woodenware) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + comradely: JSONNull?? = nil, + diacanthous: JSONNull?? = nil, + feminineness: JSONNull?? = nil, + gossamered: JSONNull?? = nil, + hibernia: JSONNull?? = nil, + hibiscus: JSONNull?? = nil, + lepidosauria: JSONNull?? = nil, + lollingly: JSONNull?? = nil, + manager: JSONNull?? = nil, + mechanic: JSONNull?? = nil, + overminuteness: JSONNull?? = nil, + papelonne: JSONNull?? = nil, + plebification: JSONNull?? = nil, + pugmiller: JSONNull?? = nil, + recoveror: JSONNull?? = nil, + spermatoblastic: JSONNull?? = nil, + syllidae: JSONNull?? = nil, + ungyved: JSONNull?? = nil, + whirlabout: JSONNull?? = nil, + woodenware: JSONNull?? = nil + ) -> Encrust { + return Encrust( + comradely: comradely ?? self.comradely, + diacanthous: diacanthous ?? self.diacanthous, + feminineness: feminineness ?? self.feminineness, + gossamered: gossamered ?? self.gossamered, + hibernia: hibernia ?? self.hibernia, + hibiscus: hibiscus ?? self.hibiscus, + lepidosauria: lepidosauria ?? self.lepidosauria, + lollingly: lollingly ?? self.lollingly, + manager: manager ?? self.manager, + mechanic: mechanic ?? self.mechanic, + overminuteness: overminuteness ?? self.overminuteness, + papelonne: papelonne ?? self.papelonne, + plebification: plebification ?? self.plebification, + pugmiller: pugmiller ?? self.pugmiller, + recoveror: recoveror ?? self.recoveror, + spermatoblastic: spermatoblastic ?? self.spermatoblastic, + syllidae: syllidae ?? self.syllidae, + ungyved: ungyved ?? self.ungyved, + whirlabout: whirlabout ?? self.whirlabout, + woodenware: woodenware ?? self.woodenware + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Epipaleolithic: Codable, Sendable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Expropriable: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum FagginglyElement: Codable, Sendable { + case double(Double) + case fagginglyClass(FagginglyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FagginglyClass.self) { + self = .fagginglyClass(x) + return + } + throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .fagginglyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FagginglyClass +@objcMembers final class FagginglyClass: NSObject, Codable, Sendable { + let abranchian: JSONNull? + let aculeiform: JSONNull? + let adiaphoristic: JSONNull? + let adoptionism: JSONNull? + let anglic: JSONNull? + let antrotomy: JSONNull? + let coerciveness: JSONNull? + let decorist: JSONNull? + let duckhood: JSONNull? + let heteromeri: JSONNull? + let hypochnose: JSONNull? + let lochage: JSONNull? + let melee: JSONNull? + let nonconformitant: JSONNull? + let poinsettia: JSONNull? + let putatively: JSONNull? + let semivolatile: JSONNull? + let soleas: JSONNull? + let unfastenable: JSONNull? + let unmillinered: JSONNull? + + enum CodingKeys: String, CodingKey { + case abranchian = "abranchian" + case aculeiform = "aculeiform" + case adiaphoristic = "adiaphoristic" + case adoptionism = "adoptionism" + case anglic = "Anglic" + case antrotomy = "antrotomy" + case coerciveness = "coerciveness" + case decorist = "decorist" + case duckhood = "duckhood" + case heteromeri = "Heteromeri" + case hypochnose = "hypochnose" + case lochage = "lochage" + case melee = "melee" + case nonconformitant = "nonconformitant" + case poinsettia = "Poinsettia" + case putatively = "putatively" + case semivolatile = "semivolatile" + case soleas = "soleas" + case unfastenable = "unfastenable" + case unmillinered = "unmillinered" + } + + init(abranchian: JSONNull?, aculeiform: JSONNull?, adiaphoristic: JSONNull?, adoptionism: JSONNull?, anglic: JSONNull?, antrotomy: JSONNull?, coerciveness: JSONNull?, decorist: JSONNull?, duckhood: JSONNull?, heteromeri: JSONNull?, hypochnose: JSONNull?, lochage: JSONNull?, melee: JSONNull?, nonconformitant: JSONNull?, poinsettia: JSONNull?, putatively: JSONNull?, semivolatile: JSONNull?, soleas: JSONNull?, unfastenable: JSONNull?, unmillinered: JSONNull?) { + self.abranchian = abranchian + self.aculeiform = aculeiform + self.adiaphoristic = adiaphoristic + self.adoptionism = adoptionism + self.anglic = anglic + self.antrotomy = antrotomy + self.coerciveness = coerciveness + self.decorist = decorist + self.duckhood = duckhood + self.heteromeri = heteromeri + self.hypochnose = hypochnose + self.lochage = lochage + self.melee = melee + self.nonconformitant = nonconformitant + self.poinsettia = poinsettia + self.putatively = putatively + self.semivolatile = semivolatile + self.soleas = soleas + self.unfastenable = unfastenable + self.unmillinered = unmillinered + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FagginglyClass.self, from: data) + self.init(abranchian: me.abranchian, aculeiform: me.aculeiform, adiaphoristic: me.adiaphoristic, adoptionism: me.adoptionism, anglic: me.anglic, antrotomy: me.antrotomy, coerciveness: me.coerciveness, decorist: me.decorist, duckhood: me.duckhood, heteromeri: me.heteromeri, hypochnose: me.hypochnose, lochage: me.lochage, melee: me.melee, nonconformitant: me.nonconformitant, poinsettia: me.poinsettia, putatively: me.putatively, semivolatile: me.semivolatile, soleas: me.soleas, unfastenable: me.unfastenable, unmillinered: me.unmillinered) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchian: JSONNull?? = nil, + aculeiform: JSONNull?? = nil, + adiaphoristic: JSONNull?? = nil, + adoptionism: JSONNull?? = nil, + anglic: JSONNull?? = nil, + antrotomy: JSONNull?? = nil, + coerciveness: JSONNull?? = nil, + decorist: JSONNull?? = nil, + duckhood: JSONNull?? = nil, + heteromeri: JSONNull?? = nil, + hypochnose: JSONNull?? = nil, + lochage: JSONNull?? = nil, + melee: JSONNull?? = nil, + nonconformitant: JSONNull?? = nil, + poinsettia: JSONNull?? = nil, + putatively: JSONNull?? = nil, + semivolatile: JSONNull?? = nil, + soleas: JSONNull?? = nil, + unfastenable: JSONNull?? = nil, + unmillinered: JSONNull?? = nil + ) -> FagginglyClass { + return FagginglyClass( + abranchian: abranchian ?? self.abranchian, + aculeiform: aculeiform ?? self.aculeiform, + adiaphoristic: adiaphoristic ?? self.adiaphoristic, + adoptionism: adoptionism ?? self.adoptionism, + anglic: anglic ?? self.anglic, + antrotomy: antrotomy ?? self.antrotomy, + coerciveness: coerciveness ?? self.coerciveness, + decorist: decorist ?? self.decorist, + duckhood: duckhood ?? self.duckhood, + heteromeri: heteromeri ?? self.heteromeri, + hypochnose: hypochnose ?? self.hypochnose, + lochage: lochage ?? self.lochage, + melee: melee ?? self.melee, + nonconformitant: nonconformitant ?? self.nonconformitant, + poinsettia: poinsettia ?? self.poinsettia, + putatively: putatively ?? self.putatively, + semivolatile: semivolatile ?? self.semivolatile, + soleas: soleas ?? self.soleas, + unfastenable: unfastenable ?? self.unfastenable, + unmillinered: unmillinered ?? self.unmillinered + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable, Sendable { + case fenkClass(FenkClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(FenkClass.self) { + self = .fenkClass(x) + return + } + throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .fenkClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - FenkClass +@objcMembers final class FenkClass: NSObject, Codable, Sendable { + let apoise: JSONNull? + let astronomize: JSONNull? + let cockhorse: JSONNull? + let copular: JSONNull? + let dagomba: JSONNull? + let draffy: JSONNull? + let foreigner: JSONNull? + let guyandot: JSONNull? + let neurogliosis: JSONNull? + let osmious: JSONNull? + let palpitate: JSONNull? + let rebukeable: JSONNull? + let reinwardtia: JSONNull? + let reservatory: JSONNull? + let scalt: JSONNull? + let scripturalize: JSONNull? + let tintometer: JSONNull? + let tritoness: JSONNull? + let undergrade: JSONNull? + let undermountain: JSONNull? + + enum CodingKeys: String, CodingKey { + case apoise = "apoise" + case astronomize = "astronomize" + case cockhorse = "cockhorse" + case copular = "copular" + case dagomba = "Dagomba" + case draffy = "draffy" + case foreigner = "foreigner" + case guyandot = "Guyandot" + case neurogliosis = "neurogliosis" + case osmious = "osmious" + case palpitate = "palpitate" + case rebukeable = "rebukeable" + case reinwardtia = "Reinwardtia" + case reservatory = "reservatory" + case scalt = "scalt" + case scripturalize = "scripturalize" + case tintometer = "tintometer" + case tritoness = "Tritoness" + case undergrade = "undergrade" + case undermountain = "undermountain" + } + + init(apoise: JSONNull?, astronomize: JSONNull?, cockhorse: JSONNull?, copular: JSONNull?, dagomba: JSONNull?, draffy: JSONNull?, foreigner: JSONNull?, guyandot: JSONNull?, neurogliosis: JSONNull?, osmious: JSONNull?, palpitate: JSONNull?, rebukeable: JSONNull?, reinwardtia: JSONNull?, reservatory: JSONNull?, scalt: JSONNull?, scripturalize: JSONNull?, tintometer: JSONNull?, tritoness: JSONNull?, undergrade: JSONNull?, undermountain: JSONNull?) { + self.apoise = apoise + self.astronomize = astronomize + self.cockhorse = cockhorse + self.copular = copular + self.dagomba = dagomba + self.draffy = draffy + self.foreigner = foreigner + self.guyandot = guyandot + self.neurogliosis = neurogliosis + self.osmious = osmious + self.palpitate = palpitate + self.rebukeable = rebukeable + self.reinwardtia = reinwardtia + self.reservatory = reservatory + self.scalt = scalt + self.scripturalize = scripturalize + self.tintometer = tintometer + self.tritoness = tritoness + self.undergrade = undergrade + self.undermountain = undermountain + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FenkClass.self, from: data) + self.init(apoise: me.apoise, astronomize: me.astronomize, cockhorse: me.cockhorse, copular: me.copular, dagomba: me.dagomba, draffy: me.draffy, foreigner: me.foreigner, guyandot: me.guyandot, neurogliosis: me.neurogliosis, osmious: me.osmious, palpitate: me.palpitate, rebukeable: me.rebukeable, reinwardtia: me.reinwardtia, reservatory: me.reservatory, scalt: me.scalt, scripturalize: me.scripturalize, tintometer: me.tintometer, tritoness: me.tritoness, undergrade: me.undergrade, undermountain: me.undermountain) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apoise: JSONNull?? = nil, + astronomize: JSONNull?? = nil, + cockhorse: JSONNull?? = nil, + copular: JSONNull?? = nil, + dagomba: JSONNull?? = nil, + draffy: JSONNull?? = nil, + foreigner: JSONNull?? = nil, + guyandot: JSONNull?? = nil, + neurogliosis: JSONNull?? = nil, + osmious: JSONNull?? = nil, + palpitate: JSONNull?? = nil, + rebukeable: JSONNull?? = nil, + reinwardtia: JSONNull?? = nil, + reservatory: JSONNull?? = nil, + scalt: JSONNull?? = nil, + scripturalize: JSONNull?? = nil, + tintometer: JSONNull?? = nil, + tritoness: JSONNull?? = nil, + undergrade: JSONNull?? = nil, + undermountain: JSONNull?? = nil + ) -> FenkClass { + return FenkClass( + apoise: apoise ?? self.apoise, + astronomize: astronomize ?? self.astronomize, + cockhorse: cockhorse ?? self.cockhorse, + copular: copular ?? self.copular, + dagomba: dagomba ?? self.dagomba, + draffy: draffy ?? self.draffy, + foreigner: foreigner ?? self.foreigner, + guyandot: guyandot ?? self.guyandot, + neurogliosis: neurogliosis ?? self.neurogliosis, + osmious: osmious ?? self.osmious, + palpitate: palpitate ?? self.palpitate, + rebukeable: rebukeable ?? self.rebukeable, + reinwardtia: reinwardtia ?? self.reinwardtia, + reservatory: reservatory ?? self.reservatory, + scalt: scalt ?? self.scalt, + scripturalize: scripturalize ?? self.scripturalize, + tintometer: tintometer ?? self.tintometer, + tritoness: tritoness ?? self.tritoness, + undergrade: undergrade ?? self.undergrade, + undermountain: undermountain ?? self.undermountain + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable, Sendable { + case bool(Bool) + case double(Double) + case flagmakingClass(FlagmakingClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FlagmakingClass.self) { + self = .flagmakingClass(x) + return + } + throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .flagmakingClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FlagmakingClass +@objcMembers final class FlagmakingClass: NSObject, Codable, Sendable { + let albarco: JSONNull? + let bunodonta: JSONNull? + let hornify: JSONNull? + let hydrocorisae: JSONNull? + let hypoglossus: JSONNull? + let inexpiably: JSONNull? + let ingratitude: JSONNull? + let ladyfly: JSONNull? + let medicament: JSONNull? + let monogrammatic: JSONNull? + let nobbut: JSONNull? + let notacanthidae: JSONNull? + let polyplacophore: JSONNull? + let proexercise: JSONNull? + let protoplast: JSONNull? + let puzzling: JSONNull? + let splanchnoskeleton: JSONNull? + let unloveliness: JSONNull? + let unquarantined: JSONNull? + let unrenounceable: JSONNull? + + enum CodingKeys: String, CodingKey { + case albarco = "albarco" + case bunodonta = "Bunodonta" + case hornify = "hornify" + case hydrocorisae = "Hydrocorisae" + case hypoglossus = "hypoglossus" + case inexpiably = "inexpiably" + case ingratitude = "ingratitude" + case ladyfly = "ladyfly" + case medicament = "medicament" + case monogrammatic = "monogrammatic" + case nobbut = "nobbut" + case notacanthidae = "Notacanthidae" + case polyplacophore = "polyplacophore" + case proexercise = "proexercise" + case protoplast = "protoplast" + case puzzling = "puzzling" + case splanchnoskeleton = "splanchnoskeleton" + case unloveliness = "unloveliness" + case unquarantined = "unquarantined" + case unrenounceable = "unrenounceable" + } + + init(albarco: JSONNull?, bunodonta: JSONNull?, hornify: JSONNull?, hydrocorisae: JSONNull?, hypoglossus: JSONNull?, inexpiably: JSONNull?, ingratitude: JSONNull?, ladyfly: JSONNull?, medicament: JSONNull?, monogrammatic: JSONNull?, nobbut: JSONNull?, notacanthidae: JSONNull?, polyplacophore: JSONNull?, proexercise: JSONNull?, protoplast: JSONNull?, puzzling: JSONNull?, splanchnoskeleton: JSONNull?, unloveliness: JSONNull?, unquarantined: JSONNull?, unrenounceable: JSONNull?) { + self.albarco = albarco + self.bunodonta = bunodonta + self.hornify = hornify + self.hydrocorisae = hydrocorisae + self.hypoglossus = hypoglossus + self.inexpiably = inexpiably + self.ingratitude = ingratitude + self.ladyfly = ladyfly + self.medicament = medicament + self.monogrammatic = monogrammatic + self.nobbut = nobbut + self.notacanthidae = notacanthidae + self.polyplacophore = polyplacophore + self.proexercise = proexercise + self.protoplast = protoplast + self.puzzling = puzzling + self.splanchnoskeleton = splanchnoskeleton + self.unloveliness = unloveliness + self.unquarantined = unquarantined + self.unrenounceable = unrenounceable + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FlagmakingClass.self, from: data) + self.init(albarco: me.albarco, bunodonta: me.bunodonta, hornify: me.hornify, hydrocorisae: me.hydrocorisae, hypoglossus: me.hypoglossus, inexpiably: me.inexpiably, ingratitude: me.ingratitude, ladyfly: me.ladyfly, medicament: me.medicament, monogrammatic: me.monogrammatic, nobbut: me.nobbut, notacanthidae: me.notacanthidae, polyplacophore: me.polyplacophore, proexercise: me.proexercise, protoplast: me.protoplast, puzzling: me.puzzling, splanchnoskeleton: me.splanchnoskeleton, unloveliness: me.unloveliness, unquarantined: me.unquarantined, unrenounceable: me.unrenounceable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + albarco: JSONNull?? = nil, + bunodonta: JSONNull?? = nil, + hornify: JSONNull?? = nil, + hydrocorisae: JSONNull?? = nil, + hypoglossus: JSONNull?? = nil, + inexpiably: JSONNull?? = nil, + ingratitude: JSONNull?? = nil, + ladyfly: JSONNull?? = nil, + medicament: JSONNull?? = nil, + monogrammatic: JSONNull?? = nil, + nobbut: JSONNull?? = nil, + notacanthidae: JSONNull?? = nil, + polyplacophore: JSONNull?? = nil, + proexercise: JSONNull?? = nil, + protoplast: JSONNull?? = nil, + puzzling: JSONNull?? = nil, + splanchnoskeleton: JSONNull?? = nil, + unloveliness: JSONNull?? = nil, + unquarantined: JSONNull?? = nil, + unrenounceable: JSONNull?? = nil + ) -> FlagmakingClass { + return FlagmakingClass( + albarco: albarco ?? self.albarco, + bunodonta: bunodonta ?? self.bunodonta, + hornify: hornify ?? self.hornify, + hydrocorisae: hydrocorisae ?? self.hydrocorisae, + hypoglossus: hypoglossus ?? self.hypoglossus, + inexpiably: inexpiably ?? self.inexpiably, + ingratitude: ingratitude ?? self.ingratitude, + ladyfly: ladyfly ?? self.ladyfly, + medicament: medicament ?? self.medicament, + monogrammatic: monogrammatic ?? self.monogrammatic, + nobbut: nobbut ?? self.nobbut, + notacanthidae: notacanthidae ?? self.notacanthidae, + polyplacophore: polyplacophore ?? self.polyplacophore, + proexercise: proexercise ?? self.proexercise, + protoplast: protoplast ?? self.protoplast, + puzzling: puzzling ?? self.puzzling, + splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton, + unloveliness: unloveliness ?? self.unloveliness, + unquarantined: unquarantined ?? self.unquarantined, + unrenounceable: unrenounceable ?? self.unrenounceable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Fluorometer: Codable, Sendable { + case integer(Int) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Fuzzy: Codable, Sendable { + case integer(Int) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Gardenward: Codable, Sendable { + case bool(Bool) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Generalissimo: Codable, Sendable { + case bool(Bool) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hemicrystalline: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum HemocoeleElement: Codable, Sendable { + case hemocoeleClass(HemocoeleClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(HemocoeleClass.self) { + self = .hemocoeleClass(x) + return + } + throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .hemocoeleClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - HemocoeleClass +@objcMembers final class HemocoeleClass: NSObject, Codable, Sendable { + let acrogamy: JSONNull? + let amelification: JSONNull? + let autobiographic: JSONNull? + let berat: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let disproportionably: JSONNull? + let erythrite: JSONNull? + let graphic: JSONNull? + let hepatological: JSONNull? + let homocerc: Bool? + let incommensurably: JSONNull? + let misaffirm: JSONNull? + let nonbookish: JSONNull? + let pocketbook: JSONNull? + let sclerometric: JSONNull? + let stambouline: JSONNull? + let stickpin: JSONNull? + let tubulure: JSONNull? + let undelated: JSONNull? + let unsalt: JSONNull? + let untutelar: JSONNull? + let vagrant: JSONNull? + let walt: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrogamy = "acrogamy" + case amelification = "amelification" + case autobiographic = "autobiographic" + case berat = "berat" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case disproportionably = "disproportionably" + case erythrite = "erythrite" + case graphic = "graphic" + case hepatological = "hepatological" + case homocerc = "homocerc" + case incommensurably = "incommensurably" + case misaffirm = "misaffirm" + case nonbookish = "nonbookish" + case pocketbook = "pocketbook" + case sclerometric = "sclerometric" + case stambouline = "stambouline" + case stickpin = "stickpin" + case tubulure = "tubulure" + case undelated = "undelated" + case unsalt = "unsalt" + case untutelar = "untutelar" + case vagrant = "vagrant" + case walt = "Walt" + } + + init(acrogamy: JSONNull?, amelification: JSONNull?, autobiographic: JSONNull?, berat: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, disproportionably: JSONNull?, erythrite: JSONNull?, graphic: JSONNull?, hepatological: JSONNull?, homocerc: Bool?, incommensurably: JSONNull?, misaffirm: JSONNull?, nonbookish: JSONNull?, pocketbook: JSONNull?, sclerometric: JSONNull?, stambouline: JSONNull?, stickpin: JSONNull?, tubulure: JSONNull?, undelated: JSONNull?, unsalt: JSONNull?, untutelar: JSONNull?, vagrant: JSONNull?, walt: JSONNull?) { + self.acrogamy = acrogamy + self.amelification = amelification + self.autobiographic = autobiographic + self.berat = berat + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.disproportionably = disproportionably + self.erythrite = erythrite + self.graphic = graphic + self.hepatological = hepatological + self.homocerc = homocerc + self.incommensurably = incommensurably + self.misaffirm = misaffirm + self.nonbookish = nonbookish + self.pocketbook = pocketbook + self.sclerometric = sclerometric + self.stambouline = stambouline + self.stickpin = stickpin + self.tubulure = tubulure + self.undelated = undelated + self.unsalt = unsalt + self.untutelar = untutelar + self.vagrant = vagrant + self.walt = walt + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(HemocoeleClass.self, from: data) + self.init(acrogamy: me.acrogamy, amelification: me.amelification, autobiographic: me.autobiographic, berat: me.berat, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, disproportionably: me.disproportionably, erythrite: me.erythrite, graphic: me.graphic, hepatological: me.hepatological, homocerc: me.homocerc, incommensurably: me.incommensurably, misaffirm: me.misaffirm, nonbookish: me.nonbookish, pocketbook: me.pocketbook, sclerometric: me.sclerometric, stambouline: me.stambouline, stickpin: me.stickpin, tubulure: me.tubulure, undelated: me.undelated, unsalt: me.unsalt, untutelar: me.untutelar, vagrant: me.vagrant, walt: me.walt) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrogamy: JSONNull?? = nil, + amelification: JSONNull?? = nil, + autobiographic: JSONNull?? = nil, + berat: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + disproportionably: JSONNull?? = nil, + erythrite: JSONNull?? = nil, + graphic: JSONNull?? = nil, + hepatological: JSONNull?? = nil, + homocerc: Bool?? = nil, + incommensurably: JSONNull?? = nil, + misaffirm: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + pocketbook: JSONNull?? = nil, + sclerometric: JSONNull?? = nil, + stambouline: JSONNull?? = nil, + stickpin: JSONNull?? = nil, + tubulure: JSONNull?? = nil, + undelated: JSONNull?? = nil, + unsalt: JSONNull?? = nil, + untutelar: JSONNull?? = nil, + vagrant: JSONNull?? = nil, + walt: JSONNull?? = nil + ) -> HemocoeleClass { + return HemocoeleClass( + acrogamy: acrogamy ?? self.acrogamy, + amelification: amelification ?? self.amelification, + autobiographic: autobiographic ?? self.autobiographic, + berat: berat ?? self.berat, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + disproportionably: disproportionably ?? self.disproportionably, + erythrite: erythrite ?? self.erythrite, + graphic: graphic ?? self.graphic, + hepatological: hepatological ?? self.hepatological, + homocerc: homocerc ?? self.homocerc, + incommensurably: incommensurably ?? self.incommensurably, + misaffirm: misaffirm ?? self.misaffirm, + nonbookish: nonbookish ?? self.nonbookish, + pocketbook: pocketbook ?? self.pocketbook, + sclerometric: sclerometric ?? self.sclerometric, + stambouline: stambouline ?? self.stambouline, + stickpin: stickpin ?? self.stickpin, + tubulure: tubulure ?? self.tubulure, + undelated: undelated ?? self.undelated, + unsalt: unsalt ?? self.unsalt, + untutelar: untutelar ?? self.untutelar, + vagrant: vagrant ?? self.vagrant, + walt: walt ?? self.walt + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyperpiesi: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyppish: Codable, Sendable { + case bool(Bool) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Idealizer: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Incrustator: Codable, Sendable { + case integer(Int) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Intentiveness: Codable, Sendable { + case cimeliaClass(CimeliaClass) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Interacinar +@objcMembers final class Interacinar: NSObject, Codable, Sendable { + let assapan: Double + let benefactorship: Bool + let triseriatim: String + let tubbing: Int + let untrimmed: JSONNull? + + enum CodingKeys: String, CodingKey { + case assapan = "assapan" + case benefactorship = "benefactorship" + case triseriatim = "triseriatim" + case tubbing = "tubbing" + case untrimmed = "untrimmed" + } + + init(assapan: Double, benefactorship: Bool, triseriatim: String, tubbing: Int, untrimmed: JSONNull?) { + self.assapan = assapan + self.benefactorship = benefactorship + self.triseriatim = triseriatim + self.tubbing = tubbing + self.untrimmed = untrimmed + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Interacinar.self, from: data) + self.init(assapan: me.assapan, benefactorship: me.benefactorship, triseriatim: me.triseriatim, tubbing: me.tubbing, untrimmed: me.untrimmed) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + assapan: Double? = nil, + benefactorship: Bool? = nil, + triseriatim: String? = nil, + tubbing: Int? = nil, + untrimmed: JSONNull?? = nil + ) -> Interacinar { + return Interacinar( + assapan: assapan ?? self.assapan, + benefactorship: benefactorship ?? self.benefactorship, + triseriatim: triseriatim ?? self.triseriatim, + tubbing: tubbing ?? self.tubbing, + untrimmed: untrimmed ?? self.untrimmed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Jacutinga: Codable, Sendable { + case integerArray([Int]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +@objcMembers final class JSONNull: NSObject, Codable, Sendable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + override public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +}