diff --git a/head/dart/test/inputs/json/priority/combinations1.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations1.json/default/TopLevel.dart new file mode 100644 index 0000000..ae9ec9d --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations1.json/default/TopLevel.dart @@ -0,0 +1,1329 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final String centrodesmose; + final List cerograph; + final List chemotherapeutics; + final List cimelia; + final int citrated; + final List clinodome; + final List coadjust; + final List consilience; + final List constructor; + final List continuative; + final List credulity; + final List creviced; + final List> cubiculum; + final List deruralize; + final List diaereses; + final List?> dissolution; + final List downstroke; + final List electrotautomerism; + final List eleutheromania; + final Encrust encrust; + final List entomoid; + final List epipaleolithic; + final List expropriable; + final List faggingly; + final List fenks; + final List flagmaking; + final List fluorometer; + final List fulsome; + final List fuzzy; + final List gardenwards; + final List generalissimo; + final List?> habeas; + final List hemicrystalline; + final List hemocoele; + final List hoister; + final List hyperpiesis; + final List hyppish; + final List idealizer; + final List incrustator; + final List intentiveness; + final Interacinar interacinar; + final List?> intercorrelation; + final List jacutinga; + + TopLevel({ + required this.centrodesmose, + required this.cerograph, + required this.chemotherapeutics, + required this.cimelia, + required this.citrated, + required this.clinodome, + required this.coadjust, + required this.consilience, + required this.constructor, + required this.continuative, + required this.credulity, + required this.creviced, + required this.cubiculum, + required this.deruralize, + required this.diaereses, + required this.dissolution, + required this.downstroke, + required this.electrotautomerism, + required this.eleutheromania, + required this.encrust, + required this.entomoid, + required this.epipaleolithic, + required this.expropriable, + required this.faggingly, + required this.fenks, + required this.flagmaking, + required this.fluorometer, + required this.fulsome, + required this.fuzzy, + required this.gardenwards, + required this.generalissimo, + required this.habeas, + required this.hemicrystalline, + required this.hemocoele, + required this.hoister, + required this.hyperpiesis, + required this.hyppish, + required this.idealizer, + required this.incrustator, + required this.intentiveness, + required this.interacinar, + required this.intercorrelation, + required this.jacutinga, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + centrodesmose: json["centrodesmose"], + cerograph: List.from(json["cerograph"].map((x) => x)), + chemotherapeutics: List.from(json["chemotherapeutics"].map((x) => x)), + cimelia: List.from(json["cimelia"].map((x) => x)), + citrated: json["citrated"], + clinodome: List.from(json["clinodome"].map((x) => x)), + coadjust: List.from(json["coadjust"].map((x) => x)), + consilience: List.from(json["consilience"].map((x) => x)), + constructor: List.from(json["constructor"].map((x) => x)), + continuative: List.from(json["continuative"].map((x) => x)), + credulity: List.from(json["credulity"].map((x) => x)), + creviced: List.from(json["creviced"].map((x) => x)), + cubiculum: List>.from(json["cubiculum"].map((x) => List.from(x.map((x) => x)))), + deruralize: List.from(json["deruralize"].map((x) => x)), + diaereses: List.from(json["diaereses"].map((x) => x)), + dissolution: List?>.from(json["dissolution"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + downstroke: List.from(json["downstroke"].map((x) => x)), + electrotautomerism: List.from(json["electrotautomerism"].map((x) => x?.toDouble())), + eleutheromania: List.from(json["eleutheromania"].map((x) => x)), + encrust: Encrust.fromJson(json["encrust"]), + entomoid: List.from(json["entomoid"].map((x) => x)), + epipaleolithic: List.from(json["epipaleolithic"].map((x) => x)), + expropriable: List.from(json["expropriable"].map((x) => x)), + faggingly: List.from(json["faggingly"].map((x) => x)), + fenks: List.from(json["fenks"].map((x) => x)), + flagmaking: List.from(json["flagmaking"].map((x) => x)), + fluorometer: List.from(json["fluorometer"].map((x) => x)), + fulsome: List.from(json["fulsome"].map((x) => x)), + fuzzy: List.from(json["fuzzy"].map((x) => x)), + gardenwards: List.from(json["gardenwards"].map((x) => x)), + generalissimo: List.from(json["generalissimo"].map((x) => x)), + habeas: List?>.from(json["habeas"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + hemicrystalline: List.from(json["hemicrystalline"].map((x) => x)), + hemocoele: List.from(json["hemocoele"].map((x) => x)), + hoister: List.from(json["hoister"].map((x) => x)), + hyperpiesis: List.from(json["hyperpiesis"].map((x) => x)), + hyppish: List.from(json["hyppish"].map((x) => x)), + idealizer: List.from(json["idealizer"].map((x) => x)), + incrustator: List.from(json["incrustator"].map((x) => x)), + intentiveness: List.from(json["intentiveness"].map((x) => x)), + interacinar: Interacinar.fromJson(json["interacinar"]), + intercorrelation: List?>.from(json["intercorrelation"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + jacutinga: List.from(json["jacutinga"].map((x) => x)), + ); + + Map toJson() => { + "centrodesmose": centrodesmose, + "cerograph": List.from(cerograph.map((x) => x)), + "chemotherapeutics": List.from(chemotherapeutics.map((x) => x)), + "cimelia": List.from(cimelia.map((x) => x)), + "citrated": citrated, + "clinodome": List.from(clinodome.map((x) => x)), + "coadjust": List.from(coadjust.map((x) => x)), + "consilience": List.from(consilience.map((x) => x)), + "constructor": List.from(constructor.map((x) => x)), + "continuative": List.from(continuative.map((x) => x)), + "credulity": List.from(credulity.map((x) => x)), + "creviced": List.from(creviced.map((x) => x)), + "cubiculum": List.from(cubiculum.map((x) => List.from(x.map((x) => x)))), + "deruralize": List.from(deruralize.map((x) => x)), + "diaereses": List.from(diaereses.map((x) => x)), + "dissolution": List.from(dissolution.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "downstroke": List.from(downstroke.map((x) => x)), + "electrotautomerism": List.from(electrotautomerism.map((x) => x)), + "eleutheromania": List.from(eleutheromania.map((x) => x)), + "encrust": encrust.toJson(), + "entomoid": List.from(entomoid.map((x) => x)), + "epipaleolithic": List.from(epipaleolithic.map((x) => x)), + "expropriable": List.from(expropriable.map((x) => x)), + "faggingly": List.from(faggingly.map((x) => x)), + "fenks": List.from(fenks.map((x) => x)), + "flagmaking": List.from(flagmaking.map((x) => x)), + "fluorometer": List.from(fluorometer.map((x) => x)), + "fulsome": List.from(fulsome.map((x) => x)), + "fuzzy": List.from(fuzzy.map((x) => x)), + "gardenwards": List.from(gardenwards.map((x) => x)), + "generalissimo": List.from(generalissimo.map((x) => x)), + "habeas": List.from(habeas.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "hemicrystalline": List.from(hemicrystalline.map((x) => x)), + "hemocoele": List.from(hemocoele.map((x) => x)), + "hoister": List.from(hoister.map((x) => x)), + "hyperpiesis": List.from(hyperpiesis.map((x) => x)), + "hyppish": List.from(hyppish.map((x) => x)), + "idealizer": List.from(idealizer.map((x) => x)), + "incrustator": List.from(incrustator.map((x) => x)), + "intentiveness": List.from(intentiveness.map((x) => x)), + "interacinar": interacinar.toJson(), + "intercorrelation": List.from(intercorrelation.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "jacutinga": List.from(jacutinga.map((x) => x)), + }; +} + +class CerographClass { + final dynamic apotropaion; + final dynamic casuary; + final dynamic creaker; + final dynamic disqualification; + final dynamic imperatorious; + final dynamic impermeabilize; + final dynamic metastoma; + final dynamic noctidiurnal; + final dynamic nonreserve; + final dynamic ophthalmotonometry; + final dynamic pailful; + final dynamic pigfish; + final dynamic pongee; + final dynamic prosodical; + final dynamic scrofuloderm; + final dynamic storekeeping; + final dynamic therologist; + final dynamic tolowa; + final dynamic tradeful; + final dynamic unriveting; + + CerographClass({ + required this.apotropaion, + required this.casuary, + required this.creaker, + required this.disqualification, + required this.imperatorious, + required this.impermeabilize, + required this.metastoma, + required this.noctidiurnal, + required this.nonreserve, + required this.ophthalmotonometry, + required this.pailful, + required this.pigfish, + required this.pongee, + required this.prosodical, + required this.scrofuloderm, + required this.storekeeping, + required this.therologist, + required this.tolowa, + required this.tradeful, + required this.unriveting, + }); + + factory CerographClass.fromJson(Map json) => CerographClass( + apotropaion: json["apotropaion"], + casuary: json["casuary"], + creaker: json["creaker"], + disqualification: json["disqualification"], + imperatorious: json["imperatorious"], + impermeabilize: json["impermeabilize"], + metastoma: json["metastoma"], + noctidiurnal: json["noctidiurnal"], + nonreserve: json["nonreserve"], + ophthalmotonometry: json["ophthalmotonometry"], + pailful: json["pailful"], + pigfish: json["pigfish"], + pongee: json["pongee"], + prosodical: json["prosodical"], + scrofuloderm: json["scrofuloderm"], + storekeeping: json["storekeeping"], + therologist: json["therologist"], + tolowa: json["Tolowa"], + tradeful: json["tradeful"], + unriveting: json["unriveting"], + ); + + Map toJson() => { + "apotropaion": apotropaion, + "casuary": casuary, + "creaker": creaker, + "disqualification": disqualification, + "imperatorious": imperatorious, + "impermeabilize": impermeabilize, + "metastoma": metastoma, + "noctidiurnal": noctidiurnal, + "nonreserve": nonreserve, + "ophthalmotonometry": ophthalmotonometry, + "pailful": pailful, + "pigfish": pigfish, + "pongee": pongee, + "prosodical": prosodical, + "scrofuloderm": scrofuloderm, + "storekeeping": storekeeping, + "therologist": therologist, + "Tolowa": tolowa, + "tradeful": tradeful, + "unriveting": unriveting, + }; +} + +class ChemotherapeuticClass { + final dynamic angioneurotic; + final dynamic availment; + final dynamic bladelet; + final double? catharticalness; + final dynamic caulis; + final dynamic chalcus; + final int? chirotherium; + final String? disdiapason; + final dynamic enteradenological; + final bool? homocerc; + final dynamic imporosity; + final dynamic insistently; + final dynamic intraparietal; + final dynamic ivied; + final dynamic maureen; + final dynamic nonbookish; + final dynamic nostochine; + final dynamic nutcracker; + final dynamic ofttimes; + final dynamic phenocryst; + final dynamic precoincident; + final dynamic ramiferous; + final dynamic stagmometer; + final dynamic tetherball; + final dynamic unshy; + + ChemotherapeuticClass({ + this.angioneurotic, + this.availment, + this.bladelet, + this.catharticalness, + this.caulis, + this.chalcus, + this.chirotherium, + this.disdiapason, + this.enteradenological, + this.homocerc, + this.imporosity, + this.insistently, + this.intraparietal, + this.ivied, + this.maureen, + this.nonbookish, + this.nostochine, + this.nutcracker, + this.ofttimes, + this.phenocryst, + this.precoincident, + this.ramiferous, + this.stagmometer, + this.tetherball, + this.unshy, + }); + + factory ChemotherapeuticClass.fromJson(Map json) => ChemotherapeuticClass( + angioneurotic: json["angioneurotic"], + availment: json["availment"], + bladelet: json["bladelet"], + catharticalness: json["catharticalness"]?.toDouble(), + caulis: json["caulis"], + chalcus: json["chalcus"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + enteradenological: json["enteradenological"], + homocerc: json["homocerc"], + imporosity: json["imporosity"], + insistently: json["insistently"], + intraparietal: json["intraparietal"], + ivied: json["ivied"], + maureen: json["Maureen"], + nonbookish: json["nonbookish"], + nostochine: json["nostochine"], + nutcracker: json["nutcracker"], + ofttimes: json["ofttimes"], + phenocryst: json["phenocryst"], + precoincident: json["precoincident"], + ramiferous: json["ramiferous"], + stagmometer: json["stagmometer"], + tetherball: json["tetherball"], + unshy: json["unshy"], + ); + + Map toJson() => { + "angioneurotic": angioneurotic, + "availment": availment, + "bladelet": bladelet, + "catharticalness": catharticalness, + "caulis": caulis, + "chalcus": chalcus, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "enteradenological": enteradenological, + "homocerc": homocerc, + "imporosity": imporosity, + "insistently": insistently, + "intraparietal": intraparietal, + "ivied": ivied, + "Maureen": maureen, + "nonbookish": nonbookish, + "nostochine": nostochine, + "nutcracker": nutcracker, + "ofttimes": ofttimes, + "phenocryst": phenocryst, + "precoincident": precoincident, + "ramiferous": ramiferous, + "stagmometer": stagmometer, + "tetherball": tetherball, + "unshy": unshy, + }; +} + +class CimeliaClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + CimeliaClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory CimeliaClass.fromJson(Map json) => CimeliaClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class CoadjustClass { + final dynamic amidosulphonal; + final dynamic benny; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final dynamic ensnare; + final bool? homocerc; + final dynamic hybridizer; + final dynamic leastwise; + final dynamic lof; + final dynamic monkhood; + final dynamic netherlandish; + final dynamic nonbookish; + final dynamic peonism; + final dynamic phonelescope; + final dynamic porphyrogeniture; + final dynamic preindemnify; + final dynamic rosal; + final dynamic scalenous; + final dynamic scopine; + final dynamic sedaceae; + final dynamic suberinize; + final dynamic symbiot; + final dynamic tablefellow; + final dynamic unchargeable; + + CoadjustClass({ + this.amidosulphonal, + this.benny, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ensnare, + this.homocerc, + this.hybridizer, + this.leastwise, + this.lof, + this.monkhood, + this.netherlandish, + this.nonbookish, + this.peonism, + this.phonelescope, + this.porphyrogeniture, + this.preindemnify, + this.rosal, + this.scalenous, + this.scopine, + this.sedaceae, + this.suberinize, + this.symbiot, + this.tablefellow, + this.unchargeable, + }); + + factory CoadjustClass.fromJson(Map json) => CoadjustClass( + amidosulphonal: json["amidosulphonal"], + benny: json["Benny"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ensnare: json["ensnare"], + homocerc: json["homocerc"], + hybridizer: json["hybridizer"], + leastwise: json["leastwise"], + lof: json["lof"], + monkhood: json["monkhood"], + netherlandish: json["Netherlandish"], + nonbookish: json["nonbookish"], + peonism: json["peonism"], + phonelescope: json["Phonelescope"], + porphyrogeniture: json["porphyrogeniture"], + preindemnify: json["preindemnify"], + rosal: json["rosal"], + scalenous: json["scalenous"], + scopine: json["scopine"], + sedaceae: json["Sedaceae"], + suberinize: json["suberinize"], + symbiot: json["symbiot"], + tablefellow: json["tablefellow"], + unchargeable: json["unchargeable"], + ); + + Map toJson() => { + "amidosulphonal": amidosulphonal, + "Benny": benny, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ensnare": ensnare, + "homocerc": homocerc, + "hybridizer": hybridizer, + "leastwise": leastwise, + "lof": lof, + "monkhood": monkhood, + "Netherlandish": netherlandish, + "nonbookish": nonbookish, + "peonism": peonism, + "Phonelescope": phonelescope, + "porphyrogeniture": porphyrogeniture, + "preindemnify": preindemnify, + "rosal": rosal, + "scalenous": scalenous, + "scopine": scopine, + "Sedaceae": sedaceae, + "suberinize": suberinize, + "symbiot": symbiot, + "tablefellow": tablefellow, + "unchargeable": unchargeable, + }; +} + +class CredulityClass { + final dynamic ammonolytic; + final dynamic bushmaster; + final dynamic considering; + final dynamic consuetudinary; + final dynamic embarras; + final dynamic fineness; + final dynamic flaithship; + final dynamic flavia; + final dynamic gruffly; + final dynamic hedychium; + final dynamic leadwort; + final dynamic overseriously; + final dynamic parabola; + final dynamic pectinatodenticulate; + final dynamic popean; + final dynamic pornocrat; + final dynamic quadrisect; + final dynamic seriality; + final dynamic vamphorn; + final dynamic wharp; + + CredulityClass({ + required this.ammonolytic, + required this.bushmaster, + required this.considering, + required this.consuetudinary, + required this.embarras, + required this.fineness, + required this.flaithship, + required this.flavia, + required this.gruffly, + required this.hedychium, + required this.leadwort, + required this.overseriously, + required this.parabola, + required this.pectinatodenticulate, + required this.popean, + required this.pornocrat, + required this.quadrisect, + required this.seriality, + required this.vamphorn, + required this.wharp, + }); + + factory CredulityClass.fromJson(Map json) => CredulityClass( + ammonolytic: json["ammonolytic"], + bushmaster: json["bushmaster"], + considering: json["considering"], + consuetudinary: json["consuetudinary"], + embarras: json["embarras"], + fineness: json["fineness"], + flaithship: json["flaithship"], + flavia: json["Flavia"], + gruffly: json["gruffly"], + hedychium: json["Hedychium"], + leadwort: json["leadwort"], + overseriously: json["overseriously"], + parabola: json["parabola"], + pectinatodenticulate: json["pectinatodenticulate"], + popean: json["Popean"], + pornocrat: json["pornocrat"], + quadrisect: json["quadrisect"], + seriality: json["seriality"], + vamphorn: json["vamphorn"], + wharp: json["wharp"], + ); + + Map toJson() => { + "ammonolytic": ammonolytic, + "bushmaster": bushmaster, + "considering": considering, + "consuetudinary": consuetudinary, + "embarras": embarras, + "fineness": fineness, + "flaithship": flaithship, + "Flavia": flavia, + "gruffly": gruffly, + "Hedychium": hedychium, + "leadwort": leadwort, + "overseriously": overseriously, + "parabola": parabola, + "pectinatodenticulate": pectinatodenticulate, + "Popean": popean, + "pornocrat": pornocrat, + "quadrisect": quadrisect, + "seriality": seriality, + "vamphorn": vamphorn, + "wharp": wharp, + }; +} + +class DeruralizeClass { + final dynamic bockerel; + final dynamic boulder; + final dynamic churrus; + final dynamic counterdigged; + final dynamic dialogite; + final dynamic digenic; + final dynamic dunbird; + final dynamic ergatogyne; + final dynamic fiendful; + final dynamic jackrod; + final dynamic jehovistic; + final dynamic paninean; + final dynamic panther; + final dynamic placentigerous; + final dynamic romney; + final dynamic sparm; + final dynamic tocsin; + final dynamic unnicked; + final dynamic unstavable; + final dynamic windfirm; + + DeruralizeClass({ + required this.bockerel, + required this.boulder, + required this.churrus, + required this.counterdigged, + required this.dialogite, + required this.digenic, + required this.dunbird, + required this.ergatogyne, + required this.fiendful, + required this.jackrod, + required this.jehovistic, + required this.paninean, + required this.panther, + required this.placentigerous, + required this.romney, + required this.sparm, + required this.tocsin, + required this.unnicked, + required this.unstavable, + required this.windfirm, + }); + + factory DeruralizeClass.fromJson(Map json) => DeruralizeClass( + bockerel: json["bockerel"], + boulder: json["boulder"], + churrus: json["churrus"], + counterdigged: json["counterdigged"], + dialogite: json["dialogite"], + digenic: json["digenic"], + dunbird: json["dunbird"], + ergatogyne: json["ergatogyne"], + fiendful: json["fiendful"], + jackrod: json["jackrod"], + jehovistic: json["Jehovistic"], + paninean: json["Paninean"], + panther: json["panther"], + placentigerous: json["placentigerous"], + romney: json["Romney"], + sparm: json["sparm"], + tocsin: json["tocsin"], + unnicked: json["unnicked"], + unstavable: json["unstavable"], + windfirm: json["windfirm"], + ); + + Map toJson() => { + "bockerel": bockerel, + "boulder": boulder, + "churrus": churrus, + "counterdigged": counterdigged, + "dialogite": dialogite, + "digenic": digenic, + "dunbird": dunbird, + "ergatogyne": ergatogyne, + "fiendful": fiendful, + "jackrod": jackrod, + "Jehovistic": jehovistic, + "Paninean": paninean, + "panther": panther, + "placentigerous": placentigerous, + "Romney": romney, + "sparm": sparm, + "tocsin": tocsin, + "unnicked": unnicked, + "unstavable": unstavable, + "windfirm": windfirm, + }; +} + +class DiaereseClass { + final dynamic amoreuxia; + final dynamic ani; + final dynamic bernicle; + final dynamic blackwasher; + final dynamic blowhard; + final dynamic broma; + final dynamic closecross; + final dynamic congregationalism; + final dynamic grayly; + final dynamic historically; + final dynamic hoast; + final dynamic irretentive; + final dynamic parcener; + final dynamic pedder; + final dynamic pseudoanatomic; + final dynamic rhizocarpian; + final dynamic samel; + final dynamic silker; + final dynamic subdentated; + final dynamic subobscure; + + DiaereseClass({ + required this.amoreuxia, + required this.ani, + required this.bernicle, + required this.blackwasher, + required this.blowhard, + required this.broma, + required this.closecross, + required this.congregationalism, + required this.grayly, + required this.historically, + required this.hoast, + required this.irretentive, + required this.parcener, + required this.pedder, + required this.pseudoanatomic, + required this.rhizocarpian, + required this.samel, + required this.silker, + required this.subdentated, + required this.subobscure, + }); + + factory DiaereseClass.fromJson(Map json) => DiaereseClass( + amoreuxia: json["Amoreuxia"], + ani: json["ani"], + bernicle: json["bernicle"], + blackwasher: json["blackwasher"], + blowhard: json["blowhard"], + broma: json["broma"], + closecross: json["closecross"], + congregationalism: json["congregationalism"], + grayly: json["grayly"], + historically: json["historically"], + hoast: json["hoast"], + irretentive: json["irretentive"], + parcener: json["parcener"], + pedder: json["pedder"], + pseudoanatomic: json["pseudoanatomic"], + rhizocarpian: json["rhizocarpian"], + samel: json["samel"], + silker: json["silker"], + subdentated: json["subdentated"], + subobscure: json["subobscure"], + ); + + Map toJson() => { + "Amoreuxia": amoreuxia, + "ani": ani, + "bernicle": bernicle, + "blackwasher": blackwasher, + "blowhard": blowhard, + "broma": broma, + "closecross": closecross, + "congregationalism": congregationalism, + "grayly": grayly, + "historically": historically, + "hoast": hoast, + "irretentive": irretentive, + "parcener": parcener, + "pedder": pedder, + "pseudoanatomic": pseudoanatomic, + "rhizocarpian": rhizocarpian, + "samel": samel, + "silker": silker, + "subdentated": subdentated, + "subobscure": subobscure, + }; +} + +class Encrust { + final dynamic comradely; + final dynamic diacanthous; + final dynamic feminineness; + final dynamic gossamered; + final dynamic hibernia; + final dynamic hibiscus; + final dynamic lepidosauria; + final dynamic lollingly; + final dynamic manager; + final dynamic mechanic; + final dynamic overminuteness; + final dynamic papelonne; + final dynamic plebification; + final dynamic pugmiller; + final dynamic recoveror; + final dynamic spermatoblastic; + final dynamic syllidae; + final dynamic ungyved; + final dynamic whirlabout; + final dynamic woodenware; + + Encrust({ + required this.comradely, + required this.diacanthous, + required this.feminineness, + required this.gossamered, + required this.hibernia, + required this.hibiscus, + required this.lepidosauria, + required this.lollingly, + required this.manager, + required this.mechanic, + required this.overminuteness, + required this.papelonne, + required this.plebification, + required this.pugmiller, + required this.recoveror, + required this.spermatoblastic, + required this.syllidae, + required this.ungyved, + required this.whirlabout, + required this.woodenware, + }); + + factory Encrust.fromJson(Map json) => Encrust( + comradely: json["comradely"], + diacanthous: json["diacanthous"], + feminineness: json["feminineness"], + gossamered: json["gossamered"], + hibernia: json["Hibernia"], + hibiscus: json["Hibiscus"], + lepidosauria: json["Lepidosauria"], + lollingly: json["lollingly"], + manager: json["manager"], + mechanic: json["mechanic"], + overminuteness: json["overminuteness"], + papelonne: json["papelonne"], + plebification: json["plebification"], + pugmiller: json["pugmiller"], + recoveror: json["recoveror"], + spermatoblastic: json["spermatoblastic"], + syllidae: json["Syllidae"], + ungyved: json["ungyved"], + whirlabout: json["whirlabout"], + woodenware: json["woodenware"], + ); + + Map toJson() => { + "comradely": comradely, + "diacanthous": diacanthous, + "feminineness": feminineness, + "gossamered": gossamered, + "Hibernia": hibernia, + "Hibiscus": hibiscus, + "Lepidosauria": lepidosauria, + "lollingly": lollingly, + "manager": manager, + "mechanic": mechanic, + "overminuteness": overminuteness, + "papelonne": papelonne, + "plebification": plebification, + "pugmiller": pugmiller, + "recoveror": recoveror, + "spermatoblastic": spermatoblastic, + "Syllidae": syllidae, + "ungyved": ungyved, + "whirlabout": whirlabout, + "woodenware": woodenware, + }; +} + +class FagginglyClass { + final dynamic abranchian; + final dynamic aculeiform; + final dynamic adiaphoristic; + final dynamic adoptionism; + final dynamic anglic; + final dynamic antrotomy; + final dynamic coerciveness; + final dynamic decorist; + final dynamic duckhood; + final dynamic heteromeri; + final dynamic hypochnose; + final dynamic lochage; + final dynamic melee; + final dynamic nonconformitant; + final dynamic poinsettia; + final dynamic putatively; + final dynamic semivolatile; + final dynamic soleas; + final dynamic unfastenable; + final dynamic unmillinered; + + FagginglyClass({ + required this.abranchian, + required this.aculeiform, + required this.adiaphoristic, + required this.adoptionism, + required this.anglic, + required this.antrotomy, + required this.coerciveness, + required this.decorist, + required this.duckhood, + required this.heteromeri, + required this.hypochnose, + required this.lochage, + required this.melee, + required this.nonconformitant, + required this.poinsettia, + required this.putatively, + required this.semivolatile, + required this.soleas, + required this.unfastenable, + required this.unmillinered, + }); + + factory FagginglyClass.fromJson(Map json) => FagginglyClass( + abranchian: json["abranchian"], + aculeiform: json["aculeiform"], + adiaphoristic: json["adiaphoristic"], + adoptionism: json["adoptionism"], + anglic: json["Anglic"], + antrotomy: json["antrotomy"], + coerciveness: json["coerciveness"], + decorist: json["decorist"], + duckhood: json["duckhood"], + heteromeri: json["Heteromeri"], + hypochnose: json["hypochnose"], + lochage: json["lochage"], + melee: json["melee"], + nonconformitant: json["nonconformitant"], + poinsettia: json["Poinsettia"], + putatively: json["putatively"], + semivolatile: json["semivolatile"], + soleas: json["soleas"], + unfastenable: json["unfastenable"], + unmillinered: json["unmillinered"], + ); + + Map toJson() => { + "abranchian": abranchian, + "aculeiform": aculeiform, + "adiaphoristic": adiaphoristic, + "adoptionism": adoptionism, + "Anglic": anglic, + "antrotomy": antrotomy, + "coerciveness": coerciveness, + "decorist": decorist, + "duckhood": duckhood, + "Heteromeri": heteromeri, + "hypochnose": hypochnose, + "lochage": lochage, + "melee": melee, + "nonconformitant": nonconformitant, + "Poinsettia": poinsettia, + "putatively": putatively, + "semivolatile": semivolatile, + "soleas": soleas, + "unfastenable": unfastenable, + "unmillinered": unmillinered, + }; +} + +class FenkClass { + final dynamic apoise; + final dynamic astronomize; + final dynamic cockhorse; + final dynamic copular; + final dynamic dagomba; + final dynamic draffy; + final dynamic foreigner; + final dynamic guyandot; + final dynamic neurogliosis; + final dynamic osmious; + final dynamic palpitate; + final dynamic rebukeable; + final dynamic reinwardtia; + final dynamic reservatory; + final dynamic scalt; + final dynamic scripturalize; + final dynamic tintometer; + final dynamic tritoness; + final dynamic undergrade; + final dynamic undermountain; + + FenkClass({ + required this.apoise, + required this.astronomize, + required this.cockhorse, + required this.copular, + required this.dagomba, + required this.draffy, + required this.foreigner, + required this.guyandot, + required this.neurogliosis, + required this.osmious, + required this.palpitate, + required this.rebukeable, + required this.reinwardtia, + required this.reservatory, + required this.scalt, + required this.scripturalize, + required this.tintometer, + required this.tritoness, + required this.undergrade, + required this.undermountain, + }); + + factory FenkClass.fromJson(Map json) => FenkClass( + apoise: json["apoise"], + astronomize: json["astronomize"], + cockhorse: json["cockhorse"], + copular: json["copular"], + dagomba: json["Dagomba"], + draffy: json["draffy"], + foreigner: json["foreigner"], + guyandot: json["Guyandot"], + neurogliosis: json["neurogliosis"], + osmious: json["osmious"], + palpitate: json["palpitate"], + rebukeable: json["rebukeable"], + reinwardtia: json["Reinwardtia"], + reservatory: json["reservatory"], + scalt: json["scalt"], + scripturalize: json["scripturalize"], + tintometer: json["tintometer"], + tritoness: json["Tritoness"], + undergrade: json["undergrade"], + undermountain: json["undermountain"], + ); + + Map toJson() => { + "apoise": apoise, + "astronomize": astronomize, + "cockhorse": cockhorse, + "copular": copular, + "Dagomba": dagomba, + "draffy": draffy, + "foreigner": foreigner, + "Guyandot": guyandot, + "neurogliosis": neurogliosis, + "osmious": osmious, + "palpitate": palpitate, + "rebukeable": rebukeable, + "Reinwardtia": reinwardtia, + "reservatory": reservatory, + "scalt": scalt, + "scripturalize": scripturalize, + "tintometer": tintometer, + "Tritoness": tritoness, + "undergrade": undergrade, + "undermountain": undermountain, + }; +} + +class FlagmakingClass { + final dynamic albarco; + final dynamic bunodonta; + final dynamic hornify; + final dynamic hydrocorisae; + final dynamic hypoglossus; + final dynamic inexpiably; + final dynamic ingratitude; + final dynamic ladyfly; + final dynamic medicament; + final dynamic monogrammatic; + final dynamic nobbut; + final dynamic notacanthidae; + final dynamic polyplacophore; + final dynamic proexercise; + final dynamic protoplast; + final dynamic puzzling; + final dynamic splanchnoskeleton; + final dynamic unloveliness; + final dynamic unquarantined; + final dynamic unrenounceable; + + FlagmakingClass({ + required this.albarco, + required this.bunodonta, + required this.hornify, + required this.hydrocorisae, + required this.hypoglossus, + required this.inexpiably, + required this.ingratitude, + required this.ladyfly, + required this.medicament, + required this.monogrammatic, + required this.nobbut, + required this.notacanthidae, + required this.polyplacophore, + required this.proexercise, + required this.protoplast, + required this.puzzling, + required this.splanchnoskeleton, + required this.unloveliness, + required this.unquarantined, + required this.unrenounceable, + }); + + factory FlagmakingClass.fromJson(Map json) => FlagmakingClass( + albarco: json["albarco"], + bunodonta: json["Bunodonta"], + hornify: json["hornify"], + hydrocorisae: json["Hydrocorisae"], + hypoglossus: json["hypoglossus"], + inexpiably: json["inexpiably"], + ingratitude: json["ingratitude"], + ladyfly: json["ladyfly"], + medicament: json["medicament"], + monogrammatic: json["monogrammatic"], + nobbut: json["nobbut"], + notacanthidae: json["Notacanthidae"], + polyplacophore: json["polyplacophore"], + proexercise: json["proexercise"], + protoplast: json["protoplast"], + puzzling: json["puzzling"], + splanchnoskeleton: json["splanchnoskeleton"], + unloveliness: json["unloveliness"], + unquarantined: json["unquarantined"], + unrenounceable: json["unrenounceable"], + ); + + Map toJson() => { + "albarco": albarco, + "Bunodonta": bunodonta, + "hornify": hornify, + "Hydrocorisae": hydrocorisae, + "hypoglossus": hypoglossus, + "inexpiably": inexpiably, + "ingratitude": ingratitude, + "ladyfly": ladyfly, + "medicament": medicament, + "monogrammatic": monogrammatic, + "nobbut": nobbut, + "Notacanthidae": notacanthidae, + "polyplacophore": polyplacophore, + "proexercise": proexercise, + "protoplast": protoplast, + "puzzling": puzzling, + "splanchnoskeleton": splanchnoskeleton, + "unloveliness": unloveliness, + "unquarantined": unquarantined, + "unrenounceable": unrenounceable, + }; +} + +class HemocoeleClass { + final dynamic acrogamy; + final dynamic amelification; + final dynamic autobiographic; + final dynamic berat; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final dynamic disproportionably; + final dynamic erythrite; + final dynamic graphic; + final dynamic hepatological; + final bool? homocerc; + final dynamic incommensurably; + final dynamic misaffirm; + final dynamic nonbookish; + final dynamic pocketbook; + final dynamic sclerometric; + final dynamic stambouline; + final dynamic stickpin; + final dynamic tubulure; + final dynamic undelated; + final dynamic unsalt; + final dynamic untutelar; + final dynamic vagrant; + final dynamic walt; + + HemocoeleClass({ + this.acrogamy, + this.amelification, + this.autobiographic, + this.berat, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.disproportionably, + this.erythrite, + this.graphic, + this.hepatological, + this.homocerc, + this.incommensurably, + this.misaffirm, + this.nonbookish, + this.pocketbook, + this.sclerometric, + this.stambouline, + this.stickpin, + this.tubulure, + this.undelated, + this.unsalt, + this.untutelar, + this.vagrant, + this.walt, + }); + + factory HemocoeleClass.fromJson(Map json) => HemocoeleClass( + acrogamy: json["acrogamy"], + amelification: json["amelification"], + autobiographic: json["autobiographic"], + berat: json["berat"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + disproportionably: json["disproportionably"], + erythrite: json["erythrite"], + graphic: json["graphic"], + hepatological: json["hepatological"], + homocerc: json["homocerc"], + incommensurably: json["incommensurably"], + misaffirm: json["misaffirm"], + nonbookish: json["nonbookish"], + pocketbook: json["pocketbook"], + sclerometric: json["sclerometric"], + stambouline: json["stambouline"], + stickpin: json["stickpin"], + tubulure: json["tubulure"], + undelated: json["undelated"], + unsalt: json["unsalt"], + untutelar: json["untutelar"], + vagrant: json["vagrant"], + walt: json["Walt"], + ); + + Map toJson() => { + "acrogamy": acrogamy, + "amelification": amelification, + "autobiographic": autobiographic, + "berat": berat, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "disproportionably": disproportionably, + "erythrite": erythrite, + "graphic": graphic, + "hepatological": hepatological, + "homocerc": homocerc, + "incommensurably": incommensurably, + "misaffirm": misaffirm, + "nonbookish": nonbookish, + "pocketbook": pocketbook, + "sclerometric": sclerometric, + "stambouline": stambouline, + "stickpin": stickpin, + "tubulure": tubulure, + "undelated": undelated, + "unsalt": unsalt, + "untutelar": untutelar, + "vagrant": vagrant, + "Walt": walt, + }; +} + +class Interacinar { + final double assapan; + final bool benefactorship; + final String triseriatim; + final int tubbing; + final dynamic untrimmed; + + Interacinar({ + required this.assapan, + required this.benefactorship, + required this.triseriatim, + required this.tubbing, + required this.untrimmed, + }); + + factory Interacinar.fromJson(Map json) => Interacinar( + assapan: json["assapan"]?.toDouble(), + benefactorship: json["benefactorship"], + triseriatim: json["triseriatim"], + tubbing: json["tubbing"], + untrimmed: json["untrimmed"], + ); + + Map toJson() => { + "assapan": assapan, + "benefactorship": benefactorship, + "triseriatim": triseriatim, + "tubbing": tubbing, + "untrimmed": untrimmed, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations1.json/final-props-false--58a791807e0c/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations1.json/final-props-false--58a791807e0c/TopLevel.dart new file mode 100644 index 0000000..5dce598 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations1.json/final-props-false--58a791807e0c/TopLevel.dart @@ -0,0 +1,1329 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + String centrodesmose; + List cerograph; + List chemotherapeutics; + List cimelia; + int citrated; + List clinodome; + List coadjust; + List consilience; + List constructor; + List continuative; + List credulity; + List creviced; + List> cubiculum; + List deruralize; + List diaereses; + List?> dissolution; + List downstroke; + List electrotautomerism; + List eleutheromania; + Encrust encrust; + List entomoid; + List epipaleolithic; + List expropriable; + List faggingly; + List fenks; + List flagmaking; + List fluorometer; + List fulsome; + List fuzzy; + List gardenwards; + List generalissimo; + List?> habeas; + List hemicrystalline; + List hemocoele; + List hoister; + List hyperpiesis; + List hyppish; + List idealizer; + List incrustator; + List intentiveness; + Interacinar interacinar; + List?> intercorrelation; + List jacutinga; + + TopLevel({ + required this.centrodesmose, + required this.cerograph, + required this.chemotherapeutics, + required this.cimelia, + required this.citrated, + required this.clinodome, + required this.coadjust, + required this.consilience, + required this.constructor, + required this.continuative, + required this.credulity, + required this.creviced, + required this.cubiculum, + required this.deruralize, + required this.diaereses, + required this.dissolution, + required this.downstroke, + required this.electrotautomerism, + required this.eleutheromania, + required this.encrust, + required this.entomoid, + required this.epipaleolithic, + required this.expropriable, + required this.faggingly, + required this.fenks, + required this.flagmaking, + required this.fluorometer, + required this.fulsome, + required this.fuzzy, + required this.gardenwards, + required this.generalissimo, + required this.habeas, + required this.hemicrystalline, + required this.hemocoele, + required this.hoister, + required this.hyperpiesis, + required this.hyppish, + required this.idealizer, + required this.incrustator, + required this.intentiveness, + required this.interacinar, + required this.intercorrelation, + required this.jacutinga, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + centrodesmose: json["centrodesmose"], + cerograph: List.from(json["cerograph"].map((x) => x)), + chemotherapeutics: List.from(json["chemotherapeutics"].map((x) => x)), + cimelia: List.from(json["cimelia"].map((x) => x)), + citrated: json["citrated"], + clinodome: List.from(json["clinodome"].map((x) => x)), + coadjust: List.from(json["coadjust"].map((x) => x)), + consilience: List.from(json["consilience"].map((x) => x)), + constructor: List.from(json["constructor"].map((x) => x)), + continuative: List.from(json["continuative"].map((x) => x)), + credulity: List.from(json["credulity"].map((x) => x)), + creviced: List.from(json["creviced"].map((x) => x)), + cubiculum: List>.from(json["cubiculum"].map((x) => List.from(x.map((x) => x)))), + deruralize: List.from(json["deruralize"].map((x) => x)), + diaereses: List.from(json["diaereses"].map((x) => x)), + dissolution: List?>.from(json["dissolution"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + downstroke: List.from(json["downstroke"].map((x) => x)), + electrotautomerism: List.from(json["electrotautomerism"].map((x) => x?.toDouble())), + eleutheromania: List.from(json["eleutheromania"].map((x) => x)), + encrust: Encrust.fromJson(json["encrust"]), + entomoid: List.from(json["entomoid"].map((x) => x)), + epipaleolithic: List.from(json["epipaleolithic"].map((x) => x)), + expropriable: List.from(json["expropriable"].map((x) => x)), + faggingly: List.from(json["faggingly"].map((x) => x)), + fenks: List.from(json["fenks"].map((x) => x)), + flagmaking: List.from(json["flagmaking"].map((x) => x)), + fluorometer: List.from(json["fluorometer"].map((x) => x)), + fulsome: List.from(json["fulsome"].map((x) => x)), + fuzzy: List.from(json["fuzzy"].map((x) => x)), + gardenwards: List.from(json["gardenwards"].map((x) => x)), + generalissimo: List.from(json["generalissimo"].map((x) => x)), + habeas: List?>.from(json["habeas"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + hemicrystalline: List.from(json["hemicrystalline"].map((x) => x)), + hemocoele: List.from(json["hemocoele"].map((x) => x)), + hoister: List.from(json["hoister"].map((x) => x)), + hyperpiesis: List.from(json["hyperpiesis"].map((x) => x)), + hyppish: List.from(json["hyppish"].map((x) => x)), + idealizer: List.from(json["idealizer"].map((x) => x)), + incrustator: List.from(json["incrustator"].map((x) => x)), + intentiveness: List.from(json["intentiveness"].map((x) => x)), + interacinar: Interacinar.fromJson(json["interacinar"]), + intercorrelation: List?>.from(json["intercorrelation"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + jacutinga: List.from(json["jacutinga"].map((x) => x)), + ); + + Map toJson() => { + "centrodesmose": centrodesmose, + "cerograph": List.from(cerograph.map((x) => x)), + "chemotherapeutics": List.from(chemotherapeutics.map((x) => x)), + "cimelia": List.from(cimelia.map((x) => x)), + "citrated": citrated, + "clinodome": List.from(clinodome.map((x) => x)), + "coadjust": List.from(coadjust.map((x) => x)), + "consilience": List.from(consilience.map((x) => x)), + "constructor": List.from(constructor.map((x) => x)), + "continuative": List.from(continuative.map((x) => x)), + "credulity": List.from(credulity.map((x) => x)), + "creviced": List.from(creviced.map((x) => x)), + "cubiculum": List.from(cubiculum.map((x) => List.from(x.map((x) => x)))), + "deruralize": List.from(deruralize.map((x) => x)), + "diaereses": List.from(diaereses.map((x) => x)), + "dissolution": List.from(dissolution.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "downstroke": List.from(downstroke.map((x) => x)), + "electrotautomerism": List.from(electrotautomerism.map((x) => x)), + "eleutheromania": List.from(eleutheromania.map((x) => x)), + "encrust": encrust.toJson(), + "entomoid": List.from(entomoid.map((x) => x)), + "epipaleolithic": List.from(epipaleolithic.map((x) => x)), + "expropriable": List.from(expropriable.map((x) => x)), + "faggingly": List.from(faggingly.map((x) => x)), + "fenks": List.from(fenks.map((x) => x)), + "flagmaking": List.from(flagmaking.map((x) => x)), + "fluorometer": List.from(fluorometer.map((x) => x)), + "fulsome": List.from(fulsome.map((x) => x)), + "fuzzy": List.from(fuzzy.map((x) => x)), + "gardenwards": List.from(gardenwards.map((x) => x)), + "generalissimo": List.from(generalissimo.map((x) => x)), + "habeas": List.from(habeas.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "hemicrystalline": List.from(hemicrystalline.map((x) => x)), + "hemocoele": List.from(hemocoele.map((x) => x)), + "hoister": List.from(hoister.map((x) => x)), + "hyperpiesis": List.from(hyperpiesis.map((x) => x)), + "hyppish": List.from(hyppish.map((x) => x)), + "idealizer": List.from(idealizer.map((x) => x)), + "incrustator": List.from(incrustator.map((x) => x)), + "intentiveness": List.from(intentiveness.map((x) => x)), + "interacinar": interacinar.toJson(), + "intercorrelation": List.from(intercorrelation.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "jacutinga": List.from(jacutinga.map((x) => x)), + }; +} + +class CerographClass { + dynamic apotropaion; + dynamic casuary; + dynamic creaker; + dynamic disqualification; + dynamic imperatorious; + dynamic impermeabilize; + dynamic metastoma; + dynamic noctidiurnal; + dynamic nonreserve; + dynamic ophthalmotonometry; + dynamic pailful; + dynamic pigfish; + dynamic pongee; + dynamic prosodical; + dynamic scrofuloderm; + dynamic storekeeping; + dynamic therologist; + dynamic tolowa; + dynamic tradeful; + dynamic unriveting; + + CerographClass({ + required this.apotropaion, + required this.casuary, + required this.creaker, + required this.disqualification, + required this.imperatorious, + required this.impermeabilize, + required this.metastoma, + required this.noctidiurnal, + required this.nonreserve, + required this.ophthalmotonometry, + required this.pailful, + required this.pigfish, + required this.pongee, + required this.prosodical, + required this.scrofuloderm, + required this.storekeeping, + required this.therologist, + required this.tolowa, + required this.tradeful, + required this.unriveting, + }); + + factory CerographClass.fromJson(Map json) => CerographClass( + apotropaion: json["apotropaion"], + casuary: json["casuary"], + creaker: json["creaker"], + disqualification: json["disqualification"], + imperatorious: json["imperatorious"], + impermeabilize: json["impermeabilize"], + metastoma: json["metastoma"], + noctidiurnal: json["noctidiurnal"], + nonreserve: json["nonreserve"], + ophthalmotonometry: json["ophthalmotonometry"], + pailful: json["pailful"], + pigfish: json["pigfish"], + pongee: json["pongee"], + prosodical: json["prosodical"], + scrofuloderm: json["scrofuloderm"], + storekeeping: json["storekeeping"], + therologist: json["therologist"], + tolowa: json["Tolowa"], + tradeful: json["tradeful"], + unriveting: json["unriveting"], + ); + + Map toJson() => { + "apotropaion": apotropaion, + "casuary": casuary, + "creaker": creaker, + "disqualification": disqualification, + "imperatorious": imperatorious, + "impermeabilize": impermeabilize, + "metastoma": metastoma, + "noctidiurnal": noctidiurnal, + "nonreserve": nonreserve, + "ophthalmotonometry": ophthalmotonometry, + "pailful": pailful, + "pigfish": pigfish, + "pongee": pongee, + "prosodical": prosodical, + "scrofuloderm": scrofuloderm, + "storekeeping": storekeeping, + "therologist": therologist, + "Tolowa": tolowa, + "tradeful": tradeful, + "unriveting": unriveting, + }; +} + +class ChemotherapeuticClass { + dynamic angioneurotic; + dynamic availment; + dynamic bladelet; + double? catharticalness; + dynamic caulis; + dynamic chalcus; + int? chirotherium; + String? disdiapason; + dynamic enteradenological; + bool? homocerc; + dynamic imporosity; + dynamic insistently; + dynamic intraparietal; + dynamic ivied; + dynamic maureen; + dynamic nonbookish; + dynamic nostochine; + dynamic nutcracker; + dynamic ofttimes; + dynamic phenocryst; + dynamic precoincident; + dynamic ramiferous; + dynamic stagmometer; + dynamic tetherball; + dynamic unshy; + + ChemotherapeuticClass({ + this.angioneurotic, + this.availment, + this.bladelet, + this.catharticalness, + this.caulis, + this.chalcus, + this.chirotherium, + this.disdiapason, + this.enteradenological, + this.homocerc, + this.imporosity, + this.insistently, + this.intraparietal, + this.ivied, + this.maureen, + this.nonbookish, + this.nostochine, + this.nutcracker, + this.ofttimes, + this.phenocryst, + this.precoincident, + this.ramiferous, + this.stagmometer, + this.tetherball, + this.unshy, + }); + + factory ChemotherapeuticClass.fromJson(Map json) => ChemotherapeuticClass( + angioneurotic: json["angioneurotic"], + availment: json["availment"], + bladelet: json["bladelet"], + catharticalness: json["catharticalness"]?.toDouble(), + caulis: json["caulis"], + chalcus: json["chalcus"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + enteradenological: json["enteradenological"], + homocerc: json["homocerc"], + imporosity: json["imporosity"], + insistently: json["insistently"], + intraparietal: json["intraparietal"], + ivied: json["ivied"], + maureen: json["Maureen"], + nonbookish: json["nonbookish"], + nostochine: json["nostochine"], + nutcracker: json["nutcracker"], + ofttimes: json["ofttimes"], + phenocryst: json["phenocryst"], + precoincident: json["precoincident"], + ramiferous: json["ramiferous"], + stagmometer: json["stagmometer"], + tetherball: json["tetherball"], + unshy: json["unshy"], + ); + + Map toJson() => { + "angioneurotic": angioneurotic, + "availment": availment, + "bladelet": bladelet, + "catharticalness": catharticalness, + "caulis": caulis, + "chalcus": chalcus, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "enteradenological": enteradenological, + "homocerc": homocerc, + "imporosity": imporosity, + "insistently": insistently, + "intraparietal": intraparietal, + "ivied": ivied, + "Maureen": maureen, + "nonbookish": nonbookish, + "nostochine": nostochine, + "nutcracker": nutcracker, + "ofttimes": ofttimes, + "phenocryst": phenocryst, + "precoincident": precoincident, + "ramiferous": ramiferous, + "stagmometer": stagmometer, + "tetherball": tetherball, + "unshy": unshy, + }; +} + +class CimeliaClass { + double catharticalness; + int chirotherium; + String disdiapason; + bool homocerc; + dynamic nonbookish; + + CimeliaClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory CimeliaClass.fromJson(Map json) => CimeliaClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class CoadjustClass { + dynamic amidosulphonal; + dynamic benny; + double? catharticalness; + int? chirotherium; + String? disdiapason; + dynamic ensnare; + bool? homocerc; + dynamic hybridizer; + dynamic leastwise; + dynamic lof; + dynamic monkhood; + dynamic netherlandish; + dynamic nonbookish; + dynamic peonism; + dynamic phonelescope; + dynamic porphyrogeniture; + dynamic preindemnify; + dynamic rosal; + dynamic scalenous; + dynamic scopine; + dynamic sedaceae; + dynamic suberinize; + dynamic symbiot; + dynamic tablefellow; + dynamic unchargeable; + + CoadjustClass({ + this.amidosulphonal, + this.benny, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ensnare, + this.homocerc, + this.hybridizer, + this.leastwise, + this.lof, + this.monkhood, + this.netherlandish, + this.nonbookish, + this.peonism, + this.phonelescope, + this.porphyrogeniture, + this.preindemnify, + this.rosal, + this.scalenous, + this.scopine, + this.sedaceae, + this.suberinize, + this.symbiot, + this.tablefellow, + this.unchargeable, + }); + + factory CoadjustClass.fromJson(Map json) => CoadjustClass( + amidosulphonal: json["amidosulphonal"], + benny: json["Benny"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ensnare: json["ensnare"], + homocerc: json["homocerc"], + hybridizer: json["hybridizer"], + leastwise: json["leastwise"], + lof: json["lof"], + monkhood: json["monkhood"], + netherlandish: json["Netherlandish"], + nonbookish: json["nonbookish"], + peonism: json["peonism"], + phonelescope: json["Phonelescope"], + porphyrogeniture: json["porphyrogeniture"], + preindemnify: json["preindemnify"], + rosal: json["rosal"], + scalenous: json["scalenous"], + scopine: json["scopine"], + sedaceae: json["Sedaceae"], + suberinize: json["suberinize"], + symbiot: json["symbiot"], + tablefellow: json["tablefellow"], + unchargeable: json["unchargeable"], + ); + + Map toJson() => { + "amidosulphonal": amidosulphonal, + "Benny": benny, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ensnare": ensnare, + "homocerc": homocerc, + "hybridizer": hybridizer, + "leastwise": leastwise, + "lof": lof, + "monkhood": monkhood, + "Netherlandish": netherlandish, + "nonbookish": nonbookish, + "peonism": peonism, + "Phonelescope": phonelescope, + "porphyrogeniture": porphyrogeniture, + "preindemnify": preindemnify, + "rosal": rosal, + "scalenous": scalenous, + "scopine": scopine, + "Sedaceae": sedaceae, + "suberinize": suberinize, + "symbiot": symbiot, + "tablefellow": tablefellow, + "unchargeable": unchargeable, + }; +} + +class CredulityClass { + dynamic ammonolytic; + dynamic bushmaster; + dynamic considering; + dynamic consuetudinary; + dynamic embarras; + dynamic fineness; + dynamic flaithship; + dynamic flavia; + dynamic gruffly; + dynamic hedychium; + dynamic leadwort; + dynamic overseriously; + dynamic parabola; + dynamic pectinatodenticulate; + dynamic popean; + dynamic pornocrat; + dynamic quadrisect; + dynamic seriality; + dynamic vamphorn; + dynamic wharp; + + CredulityClass({ + required this.ammonolytic, + required this.bushmaster, + required this.considering, + required this.consuetudinary, + required this.embarras, + required this.fineness, + required this.flaithship, + required this.flavia, + required this.gruffly, + required this.hedychium, + required this.leadwort, + required this.overseriously, + required this.parabola, + required this.pectinatodenticulate, + required this.popean, + required this.pornocrat, + required this.quadrisect, + required this.seriality, + required this.vamphorn, + required this.wharp, + }); + + factory CredulityClass.fromJson(Map json) => CredulityClass( + ammonolytic: json["ammonolytic"], + bushmaster: json["bushmaster"], + considering: json["considering"], + consuetudinary: json["consuetudinary"], + embarras: json["embarras"], + fineness: json["fineness"], + flaithship: json["flaithship"], + flavia: json["Flavia"], + gruffly: json["gruffly"], + hedychium: json["Hedychium"], + leadwort: json["leadwort"], + overseriously: json["overseriously"], + parabola: json["parabola"], + pectinatodenticulate: json["pectinatodenticulate"], + popean: json["Popean"], + pornocrat: json["pornocrat"], + quadrisect: json["quadrisect"], + seriality: json["seriality"], + vamphorn: json["vamphorn"], + wharp: json["wharp"], + ); + + Map toJson() => { + "ammonolytic": ammonolytic, + "bushmaster": bushmaster, + "considering": considering, + "consuetudinary": consuetudinary, + "embarras": embarras, + "fineness": fineness, + "flaithship": flaithship, + "Flavia": flavia, + "gruffly": gruffly, + "Hedychium": hedychium, + "leadwort": leadwort, + "overseriously": overseriously, + "parabola": parabola, + "pectinatodenticulate": pectinatodenticulate, + "Popean": popean, + "pornocrat": pornocrat, + "quadrisect": quadrisect, + "seriality": seriality, + "vamphorn": vamphorn, + "wharp": wharp, + }; +} + +class DeruralizeClass { + dynamic bockerel; + dynamic boulder; + dynamic churrus; + dynamic counterdigged; + dynamic dialogite; + dynamic digenic; + dynamic dunbird; + dynamic ergatogyne; + dynamic fiendful; + dynamic jackrod; + dynamic jehovistic; + dynamic paninean; + dynamic panther; + dynamic placentigerous; + dynamic romney; + dynamic sparm; + dynamic tocsin; + dynamic unnicked; + dynamic unstavable; + dynamic windfirm; + + DeruralizeClass({ + required this.bockerel, + required this.boulder, + required this.churrus, + required this.counterdigged, + required this.dialogite, + required this.digenic, + required this.dunbird, + required this.ergatogyne, + required this.fiendful, + required this.jackrod, + required this.jehovistic, + required this.paninean, + required this.panther, + required this.placentigerous, + required this.romney, + required this.sparm, + required this.tocsin, + required this.unnicked, + required this.unstavable, + required this.windfirm, + }); + + factory DeruralizeClass.fromJson(Map json) => DeruralizeClass( + bockerel: json["bockerel"], + boulder: json["boulder"], + churrus: json["churrus"], + counterdigged: json["counterdigged"], + dialogite: json["dialogite"], + digenic: json["digenic"], + dunbird: json["dunbird"], + ergatogyne: json["ergatogyne"], + fiendful: json["fiendful"], + jackrod: json["jackrod"], + jehovistic: json["Jehovistic"], + paninean: json["Paninean"], + panther: json["panther"], + placentigerous: json["placentigerous"], + romney: json["Romney"], + sparm: json["sparm"], + tocsin: json["tocsin"], + unnicked: json["unnicked"], + unstavable: json["unstavable"], + windfirm: json["windfirm"], + ); + + Map toJson() => { + "bockerel": bockerel, + "boulder": boulder, + "churrus": churrus, + "counterdigged": counterdigged, + "dialogite": dialogite, + "digenic": digenic, + "dunbird": dunbird, + "ergatogyne": ergatogyne, + "fiendful": fiendful, + "jackrod": jackrod, + "Jehovistic": jehovistic, + "Paninean": paninean, + "panther": panther, + "placentigerous": placentigerous, + "Romney": romney, + "sparm": sparm, + "tocsin": tocsin, + "unnicked": unnicked, + "unstavable": unstavable, + "windfirm": windfirm, + }; +} + +class DiaereseClass { + dynamic amoreuxia; + dynamic ani; + dynamic bernicle; + dynamic blackwasher; + dynamic blowhard; + dynamic broma; + dynamic closecross; + dynamic congregationalism; + dynamic grayly; + dynamic historically; + dynamic hoast; + dynamic irretentive; + dynamic parcener; + dynamic pedder; + dynamic pseudoanatomic; + dynamic rhizocarpian; + dynamic samel; + dynamic silker; + dynamic subdentated; + dynamic subobscure; + + DiaereseClass({ + required this.amoreuxia, + required this.ani, + required this.bernicle, + required this.blackwasher, + required this.blowhard, + required this.broma, + required this.closecross, + required this.congregationalism, + required this.grayly, + required this.historically, + required this.hoast, + required this.irretentive, + required this.parcener, + required this.pedder, + required this.pseudoanatomic, + required this.rhizocarpian, + required this.samel, + required this.silker, + required this.subdentated, + required this.subobscure, + }); + + factory DiaereseClass.fromJson(Map json) => DiaereseClass( + amoreuxia: json["Amoreuxia"], + ani: json["ani"], + bernicle: json["bernicle"], + blackwasher: json["blackwasher"], + blowhard: json["blowhard"], + broma: json["broma"], + closecross: json["closecross"], + congregationalism: json["congregationalism"], + grayly: json["grayly"], + historically: json["historically"], + hoast: json["hoast"], + irretentive: json["irretentive"], + parcener: json["parcener"], + pedder: json["pedder"], + pseudoanatomic: json["pseudoanatomic"], + rhizocarpian: json["rhizocarpian"], + samel: json["samel"], + silker: json["silker"], + subdentated: json["subdentated"], + subobscure: json["subobscure"], + ); + + Map toJson() => { + "Amoreuxia": amoreuxia, + "ani": ani, + "bernicle": bernicle, + "blackwasher": blackwasher, + "blowhard": blowhard, + "broma": broma, + "closecross": closecross, + "congregationalism": congregationalism, + "grayly": grayly, + "historically": historically, + "hoast": hoast, + "irretentive": irretentive, + "parcener": parcener, + "pedder": pedder, + "pseudoanatomic": pseudoanatomic, + "rhizocarpian": rhizocarpian, + "samel": samel, + "silker": silker, + "subdentated": subdentated, + "subobscure": subobscure, + }; +} + +class Encrust { + dynamic comradely; + dynamic diacanthous; + dynamic feminineness; + dynamic gossamered; + dynamic hibernia; + dynamic hibiscus; + dynamic lepidosauria; + dynamic lollingly; + dynamic manager; + dynamic mechanic; + dynamic overminuteness; + dynamic papelonne; + dynamic plebification; + dynamic pugmiller; + dynamic recoveror; + dynamic spermatoblastic; + dynamic syllidae; + dynamic ungyved; + dynamic whirlabout; + dynamic woodenware; + + Encrust({ + required this.comradely, + required this.diacanthous, + required this.feminineness, + required this.gossamered, + required this.hibernia, + required this.hibiscus, + required this.lepidosauria, + required this.lollingly, + required this.manager, + required this.mechanic, + required this.overminuteness, + required this.papelonne, + required this.plebification, + required this.pugmiller, + required this.recoveror, + required this.spermatoblastic, + required this.syllidae, + required this.ungyved, + required this.whirlabout, + required this.woodenware, + }); + + factory Encrust.fromJson(Map json) => Encrust( + comradely: json["comradely"], + diacanthous: json["diacanthous"], + feminineness: json["feminineness"], + gossamered: json["gossamered"], + hibernia: json["Hibernia"], + hibiscus: json["Hibiscus"], + lepidosauria: json["Lepidosauria"], + lollingly: json["lollingly"], + manager: json["manager"], + mechanic: json["mechanic"], + overminuteness: json["overminuteness"], + papelonne: json["papelonne"], + plebification: json["plebification"], + pugmiller: json["pugmiller"], + recoveror: json["recoveror"], + spermatoblastic: json["spermatoblastic"], + syllidae: json["Syllidae"], + ungyved: json["ungyved"], + whirlabout: json["whirlabout"], + woodenware: json["woodenware"], + ); + + Map toJson() => { + "comradely": comradely, + "diacanthous": diacanthous, + "feminineness": feminineness, + "gossamered": gossamered, + "Hibernia": hibernia, + "Hibiscus": hibiscus, + "Lepidosauria": lepidosauria, + "lollingly": lollingly, + "manager": manager, + "mechanic": mechanic, + "overminuteness": overminuteness, + "papelonne": papelonne, + "plebification": plebification, + "pugmiller": pugmiller, + "recoveror": recoveror, + "spermatoblastic": spermatoblastic, + "Syllidae": syllidae, + "ungyved": ungyved, + "whirlabout": whirlabout, + "woodenware": woodenware, + }; +} + +class FagginglyClass { + dynamic abranchian; + dynamic aculeiform; + dynamic adiaphoristic; + dynamic adoptionism; + dynamic anglic; + dynamic antrotomy; + dynamic coerciveness; + dynamic decorist; + dynamic duckhood; + dynamic heteromeri; + dynamic hypochnose; + dynamic lochage; + dynamic melee; + dynamic nonconformitant; + dynamic poinsettia; + dynamic putatively; + dynamic semivolatile; + dynamic soleas; + dynamic unfastenable; + dynamic unmillinered; + + FagginglyClass({ + required this.abranchian, + required this.aculeiform, + required this.adiaphoristic, + required this.adoptionism, + required this.anglic, + required this.antrotomy, + required this.coerciveness, + required this.decorist, + required this.duckhood, + required this.heteromeri, + required this.hypochnose, + required this.lochage, + required this.melee, + required this.nonconformitant, + required this.poinsettia, + required this.putatively, + required this.semivolatile, + required this.soleas, + required this.unfastenable, + required this.unmillinered, + }); + + factory FagginglyClass.fromJson(Map json) => FagginglyClass( + abranchian: json["abranchian"], + aculeiform: json["aculeiform"], + adiaphoristic: json["adiaphoristic"], + adoptionism: json["adoptionism"], + anglic: json["Anglic"], + antrotomy: json["antrotomy"], + coerciveness: json["coerciveness"], + decorist: json["decorist"], + duckhood: json["duckhood"], + heteromeri: json["Heteromeri"], + hypochnose: json["hypochnose"], + lochage: json["lochage"], + melee: json["melee"], + nonconformitant: json["nonconformitant"], + poinsettia: json["Poinsettia"], + putatively: json["putatively"], + semivolatile: json["semivolatile"], + soleas: json["soleas"], + unfastenable: json["unfastenable"], + unmillinered: json["unmillinered"], + ); + + Map toJson() => { + "abranchian": abranchian, + "aculeiform": aculeiform, + "adiaphoristic": adiaphoristic, + "adoptionism": adoptionism, + "Anglic": anglic, + "antrotomy": antrotomy, + "coerciveness": coerciveness, + "decorist": decorist, + "duckhood": duckhood, + "Heteromeri": heteromeri, + "hypochnose": hypochnose, + "lochage": lochage, + "melee": melee, + "nonconformitant": nonconformitant, + "Poinsettia": poinsettia, + "putatively": putatively, + "semivolatile": semivolatile, + "soleas": soleas, + "unfastenable": unfastenable, + "unmillinered": unmillinered, + }; +} + +class FenkClass { + dynamic apoise; + dynamic astronomize; + dynamic cockhorse; + dynamic copular; + dynamic dagomba; + dynamic draffy; + dynamic foreigner; + dynamic guyandot; + dynamic neurogliosis; + dynamic osmious; + dynamic palpitate; + dynamic rebukeable; + dynamic reinwardtia; + dynamic reservatory; + dynamic scalt; + dynamic scripturalize; + dynamic tintometer; + dynamic tritoness; + dynamic undergrade; + dynamic undermountain; + + FenkClass({ + required this.apoise, + required this.astronomize, + required this.cockhorse, + required this.copular, + required this.dagomba, + required this.draffy, + required this.foreigner, + required this.guyandot, + required this.neurogliosis, + required this.osmious, + required this.palpitate, + required this.rebukeable, + required this.reinwardtia, + required this.reservatory, + required this.scalt, + required this.scripturalize, + required this.tintometer, + required this.tritoness, + required this.undergrade, + required this.undermountain, + }); + + factory FenkClass.fromJson(Map json) => FenkClass( + apoise: json["apoise"], + astronomize: json["astronomize"], + cockhorse: json["cockhorse"], + copular: json["copular"], + dagomba: json["Dagomba"], + draffy: json["draffy"], + foreigner: json["foreigner"], + guyandot: json["Guyandot"], + neurogliosis: json["neurogliosis"], + osmious: json["osmious"], + palpitate: json["palpitate"], + rebukeable: json["rebukeable"], + reinwardtia: json["Reinwardtia"], + reservatory: json["reservatory"], + scalt: json["scalt"], + scripturalize: json["scripturalize"], + tintometer: json["tintometer"], + tritoness: json["Tritoness"], + undergrade: json["undergrade"], + undermountain: json["undermountain"], + ); + + Map toJson() => { + "apoise": apoise, + "astronomize": astronomize, + "cockhorse": cockhorse, + "copular": copular, + "Dagomba": dagomba, + "draffy": draffy, + "foreigner": foreigner, + "Guyandot": guyandot, + "neurogliosis": neurogliosis, + "osmious": osmious, + "palpitate": palpitate, + "rebukeable": rebukeable, + "Reinwardtia": reinwardtia, + "reservatory": reservatory, + "scalt": scalt, + "scripturalize": scripturalize, + "tintometer": tintometer, + "Tritoness": tritoness, + "undergrade": undergrade, + "undermountain": undermountain, + }; +} + +class FlagmakingClass { + dynamic albarco; + dynamic bunodonta; + dynamic hornify; + dynamic hydrocorisae; + dynamic hypoglossus; + dynamic inexpiably; + dynamic ingratitude; + dynamic ladyfly; + dynamic medicament; + dynamic monogrammatic; + dynamic nobbut; + dynamic notacanthidae; + dynamic polyplacophore; + dynamic proexercise; + dynamic protoplast; + dynamic puzzling; + dynamic splanchnoskeleton; + dynamic unloveliness; + dynamic unquarantined; + dynamic unrenounceable; + + FlagmakingClass({ + required this.albarco, + required this.bunodonta, + required this.hornify, + required this.hydrocorisae, + required this.hypoglossus, + required this.inexpiably, + required this.ingratitude, + required this.ladyfly, + required this.medicament, + required this.monogrammatic, + required this.nobbut, + required this.notacanthidae, + required this.polyplacophore, + required this.proexercise, + required this.protoplast, + required this.puzzling, + required this.splanchnoskeleton, + required this.unloveliness, + required this.unquarantined, + required this.unrenounceable, + }); + + factory FlagmakingClass.fromJson(Map json) => FlagmakingClass( + albarco: json["albarco"], + bunodonta: json["Bunodonta"], + hornify: json["hornify"], + hydrocorisae: json["Hydrocorisae"], + hypoglossus: json["hypoglossus"], + inexpiably: json["inexpiably"], + ingratitude: json["ingratitude"], + ladyfly: json["ladyfly"], + medicament: json["medicament"], + monogrammatic: json["monogrammatic"], + nobbut: json["nobbut"], + notacanthidae: json["Notacanthidae"], + polyplacophore: json["polyplacophore"], + proexercise: json["proexercise"], + protoplast: json["protoplast"], + puzzling: json["puzzling"], + splanchnoskeleton: json["splanchnoskeleton"], + unloveliness: json["unloveliness"], + unquarantined: json["unquarantined"], + unrenounceable: json["unrenounceable"], + ); + + Map toJson() => { + "albarco": albarco, + "Bunodonta": bunodonta, + "hornify": hornify, + "Hydrocorisae": hydrocorisae, + "hypoglossus": hypoglossus, + "inexpiably": inexpiably, + "ingratitude": ingratitude, + "ladyfly": ladyfly, + "medicament": medicament, + "monogrammatic": monogrammatic, + "nobbut": nobbut, + "Notacanthidae": notacanthidae, + "polyplacophore": polyplacophore, + "proexercise": proexercise, + "protoplast": protoplast, + "puzzling": puzzling, + "splanchnoskeleton": splanchnoskeleton, + "unloveliness": unloveliness, + "unquarantined": unquarantined, + "unrenounceable": unrenounceable, + }; +} + +class HemocoeleClass { + dynamic acrogamy; + dynamic amelification; + dynamic autobiographic; + dynamic berat; + double? catharticalness; + int? chirotherium; + String? disdiapason; + dynamic disproportionably; + dynamic erythrite; + dynamic graphic; + dynamic hepatological; + bool? homocerc; + dynamic incommensurably; + dynamic misaffirm; + dynamic nonbookish; + dynamic pocketbook; + dynamic sclerometric; + dynamic stambouline; + dynamic stickpin; + dynamic tubulure; + dynamic undelated; + dynamic unsalt; + dynamic untutelar; + dynamic vagrant; + dynamic walt; + + HemocoeleClass({ + this.acrogamy, + this.amelification, + this.autobiographic, + this.berat, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.disproportionably, + this.erythrite, + this.graphic, + this.hepatological, + this.homocerc, + this.incommensurably, + this.misaffirm, + this.nonbookish, + this.pocketbook, + this.sclerometric, + this.stambouline, + this.stickpin, + this.tubulure, + this.undelated, + this.unsalt, + this.untutelar, + this.vagrant, + this.walt, + }); + + factory HemocoeleClass.fromJson(Map json) => HemocoeleClass( + acrogamy: json["acrogamy"], + amelification: json["amelification"], + autobiographic: json["autobiographic"], + berat: json["berat"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + disproportionably: json["disproportionably"], + erythrite: json["erythrite"], + graphic: json["graphic"], + hepatological: json["hepatological"], + homocerc: json["homocerc"], + incommensurably: json["incommensurably"], + misaffirm: json["misaffirm"], + nonbookish: json["nonbookish"], + pocketbook: json["pocketbook"], + sclerometric: json["sclerometric"], + stambouline: json["stambouline"], + stickpin: json["stickpin"], + tubulure: json["tubulure"], + undelated: json["undelated"], + unsalt: json["unsalt"], + untutelar: json["untutelar"], + vagrant: json["vagrant"], + walt: json["Walt"], + ); + + Map toJson() => { + "acrogamy": acrogamy, + "amelification": amelification, + "autobiographic": autobiographic, + "berat": berat, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "disproportionably": disproportionably, + "erythrite": erythrite, + "graphic": graphic, + "hepatological": hepatological, + "homocerc": homocerc, + "incommensurably": incommensurably, + "misaffirm": misaffirm, + "nonbookish": nonbookish, + "pocketbook": pocketbook, + "sclerometric": sclerometric, + "stambouline": stambouline, + "stickpin": stickpin, + "tubulure": tubulure, + "undelated": undelated, + "unsalt": unsalt, + "untutelar": untutelar, + "vagrant": vagrant, + "Walt": walt, + }; +} + +class Interacinar { + double assapan; + bool benefactorship; + String triseriatim; + int tubbing; + dynamic untrimmed; + + Interacinar({ + required this.assapan, + required this.benefactorship, + required this.triseriatim, + required this.tubbing, + required this.untrimmed, + }); + + factory Interacinar.fromJson(Map json) => Interacinar( + assapan: json["assapan"]?.toDouble(), + benefactorship: json["benefactorship"], + triseriatim: json["triseriatim"], + tubbing: json["tubbing"], + untrimmed: json["untrimmed"], + ); + + Map toJson() => { + "assapan": assapan, + "benefactorship": benefactorship, + "triseriatim": triseriatim, + "tubbing": tubbing, + "untrimmed": untrimmed, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations2.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations2.json/default/TopLevel.dart new file mode 100644 index 0000000..4af4d1e --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations2.json/default/TopLevel.dart @@ -0,0 +1,1121 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final List abranchiata; + final List academe; + final List acquirable; + final List aerometry; + final List alexin; + final List alleviate; + final List amaas; + final List ambassage; + final List amphithyron; + final List andriana; + final List ankee; + final List?> annihilator; + final dynamic annulose; + final List ansarie; + final List aphasia; + final List asprawl; + final List attractive; + final Map barksome; + final List bedesman; + final List belard; + final List bocking; + final List brawlingly; + final List brookie; + final List bumboatman; + final List bystreet; + final List calaverite; + final List catallactic; + final List cemental; + final List chytridiaceae; + final List discordia; + final List endomyces; + final List epinephelidae; + final List eupatorium; + final List gryphosaurus; + final List koryak; + final List lavinia; + final List oskar; + final List rebecca; + final List rhomboganoidei; + final bool rigsmal; + final List ruellia; + final List school; + final List shakespearolater; + final List svan; + final Map wayao; + + TopLevel({ + required this.abranchiata, + required this.academe, + required this.acquirable, + required this.aerometry, + required this.alexin, + required this.alleviate, + required this.amaas, + required this.ambassage, + required this.amphithyron, + required this.andriana, + required this.ankee, + required this.annihilator, + required this.annulose, + required this.ansarie, + required this.aphasia, + required this.asprawl, + required this.attractive, + required this.barksome, + required this.bedesman, + required this.belard, + required this.bocking, + required this.brawlingly, + required this.brookie, + required this.bumboatman, + required this.bystreet, + required this.calaverite, + required this.catallactic, + required this.cemental, + required this.chytridiaceae, + required this.discordia, + required this.endomyces, + required this.epinephelidae, + required this.eupatorium, + required this.gryphosaurus, + required this.koryak, + required this.lavinia, + required this.oskar, + required this.rebecca, + required this.rhomboganoidei, + required this.rigsmal, + required this.ruellia, + required this.school, + required this.shakespearolater, + required this.svan, + required this.wayao, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + abranchiata: List.from(json["Abranchiata"].map((x) => x)), + academe: List.from(json["academe"].map((x) => x)), + acquirable: List.from(json["acquirable"].map((x) => x)), + aerometry: List.from(json["aerometry"].map((x) => x)), + alexin: List.from(json["alexin"].map((x) => x)), + alleviate: List.from(json["alleviate"].map((x) => x)), + amaas: List.from(json["amaas"].map((x) => x)), + ambassage: List.from(json["ambassage"].map((x) => x)), + amphithyron: List.from(json["amphithyron"].map((x) => x == null ? null : Amphithyron.fromJson(x))), + andriana: List.from(json["Andriana"].map((x) => x)), + ankee: List.from(json["ankee"].map((x) => x)), + annihilator: List?>.from(json["annihilator"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + annulose: json["annulose"], + ansarie: List.from(json["Ansarie"].map((x) => x)), + aphasia: List.from(json["aphasia"].map((x) => x)), + asprawl: List.from(json["asprawl"].map((x) => x)), + attractive: List.from(json["attractive"].map((x) => x)), + barksome: Map.from(json["barksome"]).map((k, v) => MapEntry(k, v)), + bedesman: List.from(json["bedesman"].map((x) => x)), + belard: List.from(json["belard"].map((x) => x)), + bocking: List.from(json["bocking"].map((x) => x)), + brawlingly: List.from(json["brawlingly"].map((x) => x)), + brookie: List.from(json["brookie"].map((x) => x)), + bumboatman: List.from(json["bumboatman"].map((x) => x)), + bystreet: List.from(json["bystreet"].map((x) => x)), + calaverite: List.from(json["calaverite"].map((x) => x)), + catallactic: List.from(json["catallactic"].map((x) => x)), + cemental: List.from(json["cemental"].map((x) => x)), + chytridiaceae: List.from(json["Chytridiaceae"].map((x) => x)), + discordia: List.from(json["Discordia"].map((x) => x)), + endomyces: List.from(json["Endomyces"].map((x) => x)), + epinephelidae: List.from(json["Epinephelidae"].map((x) => x)), + eupatorium: List.from(json["Eupatorium"].map((x) => x)), + gryphosaurus: List.from(json["Gryphosaurus"].map((x) => x)), + koryak: List.from(json["Koryak"].map((x) => x)), + lavinia: List.from(json["Lavinia"].map((x) => x)), + oskar: List.from(json["Oskar"].map((x) => x)), + rebecca: List.from(json["Rebecca"].map((x) => x)), + rhomboganoidei: List.from(json["Rhomboganoidei"].map((x) => x)), + rigsmal: json["Rigsmal"], + ruellia: List.from(json["Ruellia"].map((x) => x)), + school: List.from(json["School"].map((x) => x)), + shakespearolater: List.from(json["Shakespearolater"].map((x) => x)), + svan: List.from(json["Svan"].map((x) => x?.toDouble())), + wayao: Map.from(json["Wayao"]).map((k, v) => MapEntry(k, v?.toDouble())), + ); + + Map toJson() => { + "Abranchiata": List.from(abranchiata.map((x) => x)), + "academe": List.from(academe.map((x) => x)), + "acquirable": List.from(acquirable.map((x) => x)), + "aerometry": List.from(aerometry.map((x) => x)), + "alexin": List.from(alexin.map((x) => x)), + "alleviate": List.from(alleviate.map((x) => x)), + "amaas": List.from(amaas.map((x) => x)), + "ambassage": List.from(ambassage.map((x) => x)), + "amphithyron": List.from(amphithyron.map((x) => x?.toJson())), + "Andriana": List.from(andriana.map((x) => x)), + "ankee": List.from(ankee.map((x) => x)), + "annihilator": List.from(annihilator.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "annulose": annulose, + "Ansarie": List.from(ansarie.map((x) => x)), + "aphasia": List.from(aphasia.map((x) => x)), + "asprawl": List.from(asprawl.map((x) => x)), + "attractive": List.from(attractive.map((x) => x)), + "barksome": Map.from(barksome).map((k, v) => MapEntry(k, v)), + "bedesman": List.from(bedesman.map((x) => x)), + "belard": List.from(belard.map((x) => x)), + "bocking": List.from(bocking.map((x) => x)), + "brawlingly": List.from(brawlingly.map((x) => x)), + "brookie": List.from(brookie.map((x) => x)), + "bumboatman": List.from(bumboatman.map((x) => x)), + "bystreet": List.from(bystreet.map((x) => x)), + "calaverite": List.from(calaverite.map((x) => x)), + "catallactic": List.from(catallactic.map((x) => x)), + "cemental": List.from(cemental.map((x) => x)), + "Chytridiaceae": List.from(chytridiaceae.map((x) => x)), + "Discordia": List.from(discordia.map((x) => x)), + "Endomyces": List.from(endomyces.map((x) => x)), + "Epinephelidae": List.from(epinephelidae.map((x) => x)), + "Eupatorium": List.from(eupatorium.map((x) => x)), + "Gryphosaurus": List.from(gryphosaurus.map((x) => x)), + "Koryak": List.from(koryak.map((x) => x)), + "Lavinia": List.from(lavinia.map((x) => x)), + "Oskar": List.from(oskar.map((x) => x)), + "Rebecca": List.from(rebecca.map((x) => x)), + "Rhomboganoidei": List.from(rhomboganoidei.map((x) => x)), + "Rigsmal": rigsmal, + "Ruellia": List.from(ruellia.map((x) => x)), + "School": List.from(school.map((x) => x)), + "Shakespearolater": List.from(shakespearolater.map((x) => x)), + "Svan": List.from(svan.map((x) => x)), + "Wayao": Map.from(wayao).map((k, v) => MapEntry(k, v)), + }; +} + +class AlleviateClass { + final dynamic apriori; + final dynamic beggarer; + final dynamic brokenheartedly; + final dynamic debilitation; + final dynamic frike; + final dynamic gastrolith; + final dynamic hulsean; + final dynamic orthocentric; + final dynamic petaly; + final dynamic probudgeting; + final dynamic reacquire; + final dynamic scow; + final dynamic shutoff; + final dynamic subcontiguous; + final dynamic suffumigate; + final dynamic transformable; + final dynamic uncoroneted; + final dynamic unparking; + final dynamic unvarnishedness; + final dynamic wherewithal; + + AlleviateClass({ + required this.apriori, + required this.beggarer, + required this.brokenheartedly, + required this.debilitation, + required this.frike, + required this.gastrolith, + required this.hulsean, + required this.orthocentric, + required this.petaly, + required this.probudgeting, + required this.reacquire, + required this.scow, + required this.shutoff, + required this.subcontiguous, + required this.suffumigate, + required this.transformable, + required this.uncoroneted, + required this.unparking, + required this.unvarnishedness, + required this.wherewithal, + }); + + factory AlleviateClass.fromJson(Map json) => AlleviateClass( + apriori: json["apriori"], + beggarer: json["beggarer"], + brokenheartedly: json["brokenheartedly"], + debilitation: json["debilitation"], + frike: json["frike"], + gastrolith: json["gastrolith"], + hulsean: json["Hulsean"], + orthocentric: json["orthocentric"], + petaly: json["petaly"], + probudgeting: json["probudgeting"], + reacquire: json["reacquire"], + scow: json["scow"], + shutoff: json["shutoff"], + subcontiguous: json["subcontiguous"], + suffumigate: json["suffumigate"], + transformable: json["transformable"], + uncoroneted: json["uncoroneted"], + unparking: json["unparking"], + unvarnishedness: json["unvarnishedness"], + wherewithal: json["wherewithal"], + ); + + Map toJson() => { + "apriori": apriori, + "beggarer": beggarer, + "brokenheartedly": brokenheartedly, + "debilitation": debilitation, + "frike": frike, + "gastrolith": gastrolith, + "Hulsean": hulsean, + "orthocentric": orthocentric, + "petaly": petaly, + "probudgeting": probudgeting, + "reacquire": reacquire, + "scow": scow, + "shutoff": shutoff, + "subcontiguous": subcontiguous, + "suffumigate": suffumigate, + "transformable": transformable, + "uncoroneted": uncoroneted, + "unparking": unparking, + "unvarnishedness": unvarnishedness, + "wherewithal": wherewithal, + }; +} + +class Rebecca { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + Rebecca({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory Rebecca.fromJson(Map json) => Rebecca( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Amphithyron { + final int? akroasis; + final int? antiphonical; + final int? basebred; + final double? catharticalness; + final int? chirotherium; + final int? conductometric; + final String? disdiapason; + final int? ensilation; + final int? eyebolt; + final int? fistulated; + final int? heteropod; + final bool? homocerc; + final int? juniperus; + final int? labyrinthically; + final int? martyrization; + final int? mispolicy; + final int? multipara; + final int? nazirite; + final dynamic nonbookish; + final int? possessorial; + final int? shamed; + final int? shelfworn; + final int? stagnum; + final int? those; + final int? undecimal; + + Amphithyron({ + this.akroasis, + this.antiphonical, + this.basebred, + this.catharticalness, + this.chirotherium, + this.conductometric, + this.disdiapason, + this.ensilation, + this.eyebolt, + this.fistulated, + this.heteropod, + this.homocerc, + this.juniperus, + this.labyrinthically, + this.martyrization, + this.mispolicy, + this.multipara, + this.nazirite, + this.nonbookish, + this.possessorial, + this.shamed, + this.shelfworn, + this.stagnum, + this.those, + this.undecimal, + }); + + factory Amphithyron.fromJson(Map json) => Amphithyron( + akroasis: json["akroasis"], + antiphonical: json["antiphonical"], + basebred: json["basebred"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + conductometric: json["conductometric"], + disdiapason: json["disdiapason"], + ensilation: json["ensilation"], + eyebolt: json["eyebolt"], + fistulated: json["fistulated"], + heteropod: json["heteropod"], + homocerc: json["homocerc"], + juniperus: json["Juniperus"], + labyrinthically: json["labyrinthically"], + martyrization: json["martyrization"], + mispolicy: json["mispolicy"], + multipara: json["multipara"], + nazirite: json["Nazirite"], + nonbookish: json["nonbookish"], + possessorial: json["possessorial"], + shamed: json["shamed"], + shelfworn: json["shelfworn"], + stagnum: json["stagnum"], + those: json["Those"], + undecimal: json["undecimal"], + ); + + Map toJson() => { + "akroasis": akroasis, + "antiphonical": antiphonical, + "basebred": basebred, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "conductometric": conductometric, + "disdiapason": disdiapason, + "ensilation": ensilation, + "eyebolt": eyebolt, + "fistulated": fistulated, + "heteropod": heteropod, + "homocerc": homocerc, + "Juniperus": juniperus, + "labyrinthically": labyrinthically, + "martyrization": martyrization, + "mispolicy": mispolicy, + "multipara": multipara, + "Nazirite": nazirite, + "nonbookish": nonbookish, + "possessorial": possessorial, + "shamed": shamed, + "shelfworn": shelfworn, + "stagnum": stagnum, + "Those": those, + "undecimal": undecimal, + }; +} + +class AnkeeClass { + final dynamic anomoean; + final dynamic barleyhood; + final dynamic befriender; + final dynamic brutishness; + final dynamic cephalalgy; + final dynamic cirurgian; + final dynamic conventionally; + final dynamic jackshay; + final dynamic milammeter; + final dynamic naja; + final dynamic ombrological; + final dynamic phonasthenia; + final dynamic retrievableness; + final dynamic snakily; + final dynamic swot; + final dynamic tartlet; + final dynamic thiofuran; + final dynamic tracheophone; + final dynamic tuglike; + final dynamic unscratchingly; + + AnkeeClass({ + required this.anomoean, + required this.barleyhood, + required this.befriender, + required this.brutishness, + required this.cephalalgy, + required this.cirurgian, + required this.conventionally, + required this.jackshay, + required this.milammeter, + required this.naja, + required this.ombrological, + required this.phonasthenia, + required this.retrievableness, + required this.snakily, + required this.swot, + required this.tartlet, + required this.thiofuran, + required this.tracheophone, + required this.tuglike, + required this.unscratchingly, + }); + + factory AnkeeClass.fromJson(Map json) => AnkeeClass( + anomoean: json["Anomoean"], + barleyhood: json["barleyhood"], + befriender: json["befriender"], + brutishness: json["brutishness"], + cephalalgy: json["cephalalgy"], + cirurgian: json["cirurgian"], + conventionally: json["conventionally"], + jackshay: json["jackshay"], + milammeter: json["milammeter"], + naja: json["Naja"], + ombrological: json["ombrological"], + phonasthenia: json["phonasthenia"], + retrievableness: json["retrievableness"], + snakily: json["snakily"], + swot: json["swot"], + tartlet: json["tartlet"], + thiofuran: json["thiofuran"], + tracheophone: json["tracheophone"], + tuglike: json["tuglike"], + unscratchingly: json["unscratchingly"], + ); + + Map toJson() => { + "Anomoean": anomoean, + "barleyhood": barleyhood, + "befriender": befriender, + "brutishness": brutishness, + "cephalalgy": cephalalgy, + "cirurgian": cirurgian, + "conventionally": conventionally, + "jackshay": jackshay, + "milammeter": milammeter, + "Naja": naja, + "ombrological": ombrological, + "phonasthenia": phonasthenia, + "retrievableness": retrievableness, + "snakily": snakily, + "swot": swot, + "tartlet": tartlet, + "thiofuran": thiofuran, + "tracheophone": tracheophone, + "tuglike": tuglike, + "unscratchingly": unscratchingly, + }; +} + +class AnsarieClass { + final dynamic accension; + final dynamic alida; + final dynamic asteria; + final dynamic beriberic; + final dynamic edgebone; + final dynamic gastrodialysis; + final dynamic geographic; + final dynamic ictonyx; + final dynamic metrocele; + final dynamic misgraft; + final dynamic monteith; + final dynamic notcher; + final dynamic prorestriction; + final dynamic ramist; + final dynamic throatlet; + final dynamic unfair; + final dynamic unsynonymous; + final dynamic water; + final dynamic zestfully; + final dynamic zincic; + + AnsarieClass({ + required this.accension, + required this.alida, + required this.asteria, + required this.beriberic, + required this.edgebone, + required this.gastrodialysis, + required this.geographic, + required this.ictonyx, + required this.metrocele, + required this.misgraft, + required this.monteith, + required this.notcher, + required this.prorestriction, + required this.ramist, + required this.throatlet, + required this.unfair, + required this.unsynonymous, + required this.water, + required this.zestfully, + required this.zincic, + }); + + factory AnsarieClass.fromJson(Map json) => AnsarieClass( + accension: json["accension"], + alida: json["Alida"], + asteria: json["asteria"], + beriberic: json["beriberic"], + edgebone: json["edgebone"], + gastrodialysis: json["gastrodialysis"], + geographic: json["geographic"], + ictonyx: json["Ictonyx"], + metrocele: json["metrocele"], + misgraft: json["misgraft"], + monteith: json["monteith"], + notcher: json["notcher"], + prorestriction: json["prorestriction"], + ramist: json["Ramist"], + throatlet: json["throatlet"], + unfair: json["unfair"], + unsynonymous: json["unsynonymous"], + water: json["water"], + zestfully: json["zestfully"], + zincic: json["zincic"], + ); + + Map toJson() => { + "accension": accension, + "Alida": alida, + "asteria": asteria, + "beriberic": beriberic, + "edgebone": edgebone, + "gastrodialysis": gastrodialysis, + "geographic": geographic, + "Ictonyx": ictonyx, + "metrocele": metrocele, + "misgraft": misgraft, + "monteith": monteith, + "notcher": notcher, + "prorestriction": prorestriction, + "Ramist": ramist, + "throatlet": throatlet, + "unfair": unfair, + "unsynonymous": unsynonymous, + "water": water, + "zestfully": zestfully, + "zincic": zincic, + }; +} + +class ChytridiaceaeClass { + final dynamic batidaceae; + final dynamic brechites; + final dynamic codespairer; + final dynamic emery; + final dynamic enervative; + final dynamic excriminate; + final dynamic goshenite; + final dynamic grime; + final dynamic gritten; + final dynamic hectorly; + final dynamic intermediation; + final dynamic meeterly; + final dynamic narraganset; + final dynamic onymatic; + final dynamic paddlecock; + final dynamic thana; + final dynamic thornily; + final dynamic uckia; + final dynamic unmettle; + final dynamic vorticellid; + + ChytridiaceaeClass({ + required this.batidaceae, + required this.brechites, + required this.codespairer, + required this.emery, + required this.enervative, + required this.excriminate, + required this.goshenite, + required this.grime, + required this.gritten, + required this.hectorly, + required this.intermediation, + required this.meeterly, + required this.narraganset, + required this.onymatic, + required this.paddlecock, + required this.thana, + required this.thornily, + required this.uckia, + required this.unmettle, + required this.vorticellid, + }); + + factory ChytridiaceaeClass.fromJson(Map json) => ChytridiaceaeClass( + batidaceae: json["Batidaceae"], + brechites: json["Brechites"], + codespairer: json["codespairer"], + emery: json["Emery"], + enervative: json["enervative"], + excriminate: json["excriminate"], + goshenite: json["goshenite"], + grime: json["grime"], + gritten: json["gritten"], + hectorly: json["hectorly"], + intermediation: json["intermediation"], + meeterly: json["meeterly"], + narraganset: json["Narraganset"], + onymatic: json["onymatic"], + paddlecock: json["paddlecock"], + thana: json["thana"], + thornily: json["thornily"], + uckia: json["uckia"], + unmettle: json["unmettle"], + vorticellid: json["vorticellid"], + ); + + Map toJson() => { + "Batidaceae": batidaceae, + "Brechites": brechites, + "codespairer": codespairer, + "Emery": emery, + "enervative": enervative, + "excriminate": excriminate, + "goshenite": goshenite, + "grime": grime, + "gritten": gritten, + "hectorly": hectorly, + "intermediation": intermediation, + "meeterly": meeterly, + "Narraganset": narraganset, + "onymatic": onymatic, + "paddlecock": paddlecock, + "thana": thana, + "thornily": thornily, + "uckia": uckia, + "unmettle": unmettle, + "vorticellid": vorticellid, + }; +} + +class DiscordiaClass { + final int? altaic; + final int? amoristic; + final int? blennophthalmia; + final double? catharticalness; + final int? chirotherium; + final int? disciplinability; + final String? disdiapason; + final int? goofer; + final bool? homocerc; + final int? laryngograph; + final int? leucitis; + final int? lymphocyst; + final int? microcosmology; + final int? nauseation; + final dynamic nonbookish; + final int? patarin; + final int? preliberal; + final int? prettifier; + final int? rangework; + final int? redient; + final int? subfusiform; + final int? suicidical; + final int? swow; + final int? wastrel; + final int? wingle; + + DiscordiaClass({ + this.altaic, + this.amoristic, + this.blennophthalmia, + this.catharticalness, + this.chirotherium, + this.disciplinability, + this.disdiapason, + this.goofer, + this.homocerc, + this.laryngograph, + this.leucitis, + this.lymphocyst, + this.microcosmology, + this.nauseation, + this.nonbookish, + this.patarin, + this.preliberal, + this.prettifier, + this.rangework, + this.redient, + this.subfusiform, + this.suicidical, + this.swow, + this.wastrel, + this.wingle, + }); + + factory DiscordiaClass.fromJson(Map json) => DiscordiaClass( + altaic: json["Altaic"], + amoristic: json["amoristic"], + blennophthalmia: json["blennophthalmia"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disciplinability: json["disciplinability"], + disdiapason: json["disdiapason"], + goofer: json["goofer"], + homocerc: json["homocerc"], + laryngograph: json["laryngograph"], + leucitis: json["leucitis"], + lymphocyst: json["lymphocyst"], + microcosmology: json["microcosmology"], + nauseation: json["nauseation"], + nonbookish: json["nonbookish"], + patarin: json["Patarin"], + preliberal: json["preliberal"], + prettifier: json["prettifier"], + rangework: json["rangework"], + redient: json["redient"], + subfusiform: json["subfusiform"], + suicidical: json["suicidical"], + swow: json["swow"], + wastrel: json["wastrel"], + wingle: json["wingle"], + ); + + Map toJson() => { + "Altaic": altaic, + "amoristic": amoristic, + "blennophthalmia": blennophthalmia, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disciplinability": disciplinability, + "disdiapason": disdiapason, + "goofer": goofer, + "homocerc": homocerc, + "laryngograph": laryngograph, + "leucitis": leucitis, + "lymphocyst": lymphocyst, + "microcosmology": microcosmology, + "nauseation": nauseation, + "nonbookish": nonbookish, + "Patarin": patarin, + "preliberal": preliberal, + "prettifier": prettifier, + "rangework": rangework, + "redient": redient, + "subfusiform": subfusiform, + "suicidical": suicidical, + "swow": swow, + "wastrel": wastrel, + "wingle": wingle, + }; +} + +class GryphosaurusClass { + final dynamic amissibility; + final dynamic burushaski; + final dynamic citronin; + final dynamic coplaintiff; + final dynamic disquisitionary; + final dynamic enoplan; + final dynamic faintness; + final dynamic hebetomy; + final dynamic islandry; + final dynamic lameduck; + final dynamic overbattle; + final dynamic overinterested; + final dynamic phrenologic; + final dynamic rainband; + final dynamic shiningly; + final dynamic stamineous; + final dynamic subscapularis; + final dynamic tahami; + final dynamic undaubed; + final dynamic underntime; + + GryphosaurusClass({ + required this.amissibility, + required this.burushaski, + required this.citronin, + required this.coplaintiff, + required this.disquisitionary, + required this.enoplan, + required this.faintness, + required this.hebetomy, + required this.islandry, + required this.lameduck, + required this.overbattle, + required this.overinterested, + required this.phrenologic, + required this.rainband, + required this.shiningly, + required this.stamineous, + required this.subscapularis, + required this.tahami, + required this.undaubed, + required this.underntime, + }); + + factory GryphosaurusClass.fromJson(Map json) => GryphosaurusClass( + amissibility: json["amissibility"], + burushaski: json["Burushaski"], + citronin: json["citronin"], + coplaintiff: json["coplaintiff"], + disquisitionary: json["disquisitionary"], + enoplan: json["enoplan"], + faintness: json["faintness"], + hebetomy: json["hebetomy"], + islandry: json["islandry"], + lameduck: json["lameduck"], + overbattle: json["overbattle"], + overinterested: json["overinterested"], + phrenologic: json["phrenologic"], + rainband: json["rainband"], + shiningly: json["shiningly"], + stamineous: json["stamineous"], + subscapularis: json["subscapularis"], + tahami: json["Tahami"], + undaubed: json["undaubed"], + underntime: json["underntime"], + ); + + Map toJson() => { + "amissibility": amissibility, + "Burushaski": burushaski, + "citronin": citronin, + "coplaintiff": coplaintiff, + "disquisitionary": disquisitionary, + "enoplan": enoplan, + "faintness": faintness, + "hebetomy": hebetomy, + "islandry": islandry, + "lameduck": lameduck, + "overbattle": overbattle, + "overinterested": overinterested, + "phrenologic": phrenologic, + "rainband": rainband, + "shiningly": shiningly, + "stamineous": stamineous, + "subscapularis": subscapularis, + "Tahami": tahami, + "undaubed": undaubed, + "underntime": underntime, + }; +} + +class LaviniaClass { + final int? agitable; + final int? asininity; + final int? benefiter; + final int? bronzelike; + final double? catharticalness; + final int? chirotherium; + final int? cholesteatomatous; + final int? deprivement; + final String? disdiapason; + final int? flippantness; + final int? fogproof; + final bool? homocerc; + final int? merrymeeting; + final dynamic nonbookish; + final int? overcareful; + final int? panaris; + final int? preacceptance; + final int? quinoxaline; + final int? sig; + final int? superconfusion; + final int? tacana; + final int? tillotter; + final int? tranquillize; + final int? unquestionable; + final int? uproute; + + LaviniaClass({ + this.agitable, + this.asininity, + this.benefiter, + this.bronzelike, + this.catharticalness, + this.chirotherium, + this.cholesteatomatous, + this.deprivement, + this.disdiapason, + this.flippantness, + this.fogproof, + this.homocerc, + this.merrymeeting, + this.nonbookish, + this.overcareful, + this.panaris, + this.preacceptance, + this.quinoxaline, + this.sig, + this.superconfusion, + this.tacana, + this.tillotter, + this.tranquillize, + this.unquestionable, + this.uproute, + }); + + factory LaviniaClass.fromJson(Map json) => LaviniaClass( + agitable: json["agitable"], + asininity: json["asininity"], + benefiter: json["benefiter"], + bronzelike: json["bronzelike"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cholesteatomatous: json["cholesteatomatous"], + deprivement: json["deprivement"], + disdiapason: json["disdiapason"], + flippantness: json["flippantness"], + fogproof: json["fogproof"], + homocerc: json["homocerc"], + merrymeeting: json["merrymeeting"], + nonbookish: json["nonbookish"], + overcareful: json["overcareful"], + panaris: json["panaris"], + preacceptance: json["preacceptance"], + quinoxaline: json["quinoxaline"], + sig: json["sig"], + superconfusion: json["superconfusion"], + tacana: json["Tacana"], + tillotter: json["tillotter"], + tranquillize: json["tranquillize"], + unquestionable: json["unquestionable"], + uproute: json["uproute"], + ); + + Map toJson() => { + "agitable": agitable, + "asininity": asininity, + "benefiter": benefiter, + "bronzelike": bronzelike, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cholesteatomatous": cholesteatomatous, + "deprivement": deprivement, + "disdiapason": disdiapason, + "flippantness": flippantness, + "fogproof": fogproof, + "homocerc": homocerc, + "merrymeeting": merrymeeting, + "nonbookish": nonbookish, + "overcareful": overcareful, + "panaris": panaris, + "preacceptance": preacceptance, + "quinoxaline": quinoxaline, + "sig": sig, + "superconfusion": superconfusion, + "Tacana": tacana, + "tillotter": tillotter, + "tranquillize": tranquillize, + "unquestionable": unquestionable, + "uproute": uproute, + }; +} + +class OskarClass { + final dynamic acrobates; + final dynamic beanshooter; + final dynamic bearhound; + final dynamic cayuga; + final dynamic guarneri; + final dynamic hypochondriacism; + final dynamic indication; + final dynamic jaculative; + final dynamic nagana; + final dynamic netherlandish; + final dynamic noctivagous; + final dynamic nonphysiological; + final dynamic praxis; + final dynamic provision; + final dynamic subterhuman; + final dynamic sunlit; + final dynamic syncraniate; + final dynamic teachment; + final dynamic unmutinous; + final dynamic unstoppable; + + OskarClass({ + required this.acrobates, + required this.beanshooter, + required this.bearhound, + required this.cayuga, + required this.guarneri, + required this.hypochondriacism, + required this.indication, + required this.jaculative, + required this.nagana, + required this.netherlandish, + required this.noctivagous, + required this.nonphysiological, + required this.praxis, + required this.provision, + required this.subterhuman, + required this.sunlit, + required this.syncraniate, + required this.teachment, + required this.unmutinous, + required this.unstoppable, + }); + + factory OskarClass.fromJson(Map json) => OskarClass( + acrobates: json["Acrobates"], + beanshooter: json["beanshooter"], + bearhound: json["bearhound"], + cayuga: json["Cayuga"], + guarneri: json["guarneri"], + hypochondriacism: json["hypochondriacism"], + indication: json["indication"], + jaculative: json["jaculative"], + nagana: json["nagana"], + netherlandish: json["Netherlandish"], + noctivagous: json["noctivagous"], + nonphysiological: json["nonphysiological"], + praxis: json["praxis"], + provision: json["provision"], + subterhuman: json["subterhuman"], + sunlit: json["sunlit"], + syncraniate: json["syncraniate"], + teachment: json["teachment"], + unmutinous: json["unmutinous"], + unstoppable: json["unstoppable"], + ); + + Map toJson() => { + "Acrobates": acrobates, + "beanshooter": beanshooter, + "bearhound": bearhound, + "Cayuga": cayuga, + "guarneri": guarneri, + "hypochondriacism": hypochondriacism, + "indication": indication, + "jaculative": jaculative, + "nagana": nagana, + "Netherlandish": netherlandish, + "noctivagous": noctivagous, + "nonphysiological": nonphysiological, + "praxis": praxis, + "provision": provision, + "subterhuman": subterhuman, + "sunlit": sunlit, + "syncraniate": syncraniate, + "teachment": teachment, + "unmutinous": unmutinous, + "unstoppable": unstoppable, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations2.json/final-props-false--58a791807e0c/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations2.json/final-props-false--58a791807e0c/TopLevel.dart new file mode 100644 index 0000000..e021409 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations2.json/final-props-false--58a791807e0c/TopLevel.dart @@ -0,0 +1,1121 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + List abranchiata; + List academe; + List acquirable; + List aerometry; + List alexin; + List alleviate; + List amaas; + List ambassage; + List amphithyron; + List andriana; + List ankee; + List?> annihilator; + dynamic annulose; + List ansarie; + List aphasia; + List asprawl; + List attractive; + Map barksome; + List bedesman; + List belard; + List bocking; + List brawlingly; + List brookie; + List bumboatman; + List bystreet; + List calaverite; + List catallactic; + List cemental; + List chytridiaceae; + List discordia; + List endomyces; + List epinephelidae; + List eupatorium; + List gryphosaurus; + List koryak; + List lavinia; + List oskar; + List rebecca; + List rhomboganoidei; + bool rigsmal; + List ruellia; + List school; + List shakespearolater; + List svan; + Map wayao; + + TopLevel({ + required this.abranchiata, + required this.academe, + required this.acquirable, + required this.aerometry, + required this.alexin, + required this.alleviate, + required this.amaas, + required this.ambassage, + required this.amphithyron, + required this.andriana, + required this.ankee, + required this.annihilator, + required this.annulose, + required this.ansarie, + required this.aphasia, + required this.asprawl, + required this.attractive, + required this.barksome, + required this.bedesman, + required this.belard, + required this.bocking, + required this.brawlingly, + required this.brookie, + required this.bumboatman, + required this.bystreet, + required this.calaverite, + required this.catallactic, + required this.cemental, + required this.chytridiaceae, + required this.discordia, + required this.endomyces, + required this.epinephelidae, + required this.eupatorium, + required this.gryphosaurus, + required this.koryak, + required this.lavinia, + required this.oskar, + required this.rebecca, + required this.rhomboganoidei, + required this.rigsmal, + required this.ruellia, + required this.school, + required this.shakespearolater, + required this.svan, + required this.wayao, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + abranchiata: List.from(json["Abranchiata"].map((x) => x)), + academe: List.from(json["academe"].map((x) => x)), + acquirable: List.from(json["acquirable"].map((x) => x)), + aerometry: List.from(json["aerometry"].map((x) => x)), + alexin: List.from(json["alexin"].map((x) => x)), + alleviate: List.from(json["alleviate"].map((x) => x)), + amaas: List.from(json["amaas"].map((x) => x)), + ambassage: List.from(json["ambassage"].map((x) => x)), + amphithyron: List.from(json["amphithyron"].map((x) => x == null ? null : Amphithyron.fromJson(x))), + andriana: List.from(json["Andriana"].map((x) => x)), + ankee: List.from(json["ankee"].map((x) => x)), + annihilator: List?>.from(json["annihilator"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + annulose: json["annulose"], + ansarie: List.from(json["Ansarie"].map((x) => x)), + aphasia: List.from(json["aphasia"].map((x) => x)), + asprawl: List.from(json["asprawl"].map((x) => x)), + attractive: List.from(json["attractive"].map((x) => x)), + barksome: Map.from(json["barksome"]).map((k, v) => MapEntry(k, v)), + bedesman: List.from(json["bedesman"].map((x) => x)), + belard: List.from(json["belard"].map((x) => x)), + bocking: List.from(json["bocking"].map((x) => x)), + brawlingly: List.from(json["brawlingly"].map((x) => x)), + brookie: List.from(json["brookie"].map((x) => x)), + bumboatman: List.from(json["bumboatman"].map((x) => x)), + bystreet: List.from(json["bystreet"].map((x) => x)), + calaverite: List.from(json["calaverite"].map((x) => x)), + catallactic: List.from(json["catallactic"].map((x) => x)), + cemental: List.from(json["cemental"].map((x) => x)), + chytridiaceae: List.from(json["Chytridiaceae"].map((x) => x)), + discordia: List.from(json["Discordia"].map((x) => x)), + endomyces: List.from(json["Endomyces"].map((x) => x)), + epinephelidae: List.from(json["Epinephelidae"].map((x) => x)), + eupatorium: List.from(json["Eupatorium"].map((x) => x)), + gryphosaurus: List.from(json["Gryphosaurus"].map((x) => x)), + koryak: List.from(json["Koryak"].map((x) => x)), + lavinia: List.from(json["Lavinia"].map((x) => x)), + oskar: List.from(json["Oskar"].map((x) => x)), + rebecca: List.from(json["Rebecca"].map((x) => x)), + rhomboganoidei: List.from(json["Rhomboganoidei"].map((x) => x)), + rigsmal: json["Rigsmal"], + ruellia: List.from(json["Ruellia"].map((x) => x)), + school: List.from(json["School"].map((x) => x)), + shakespearolater: List.from(json["Shakespearolater"].map((x) => x)), + svan: List.from(json["Svan"].map((x) => x?.toDouble())), + wayao: Map.from(json["Wayao"]).map((k, v) => MapEntry(k, v?.toDouble())), + ); + + Map toJson() => { + "Abranchiata": List.from(abranchiata.map((x) => x)), + "academe": List.from(academe.map((x) => x)), + "acquirable": List.from(acquirable.map((x) => x)), + "aerometry": List.from(aerometry.map((x) => x)), + "alexin": List.from(alexin.map((x) => x)), + "alleviate": List.from(alleviate.map((x) => x)), + "amaas": List.from(amaas.map((x) => x)), + "ambassage": List.from(ambassage.map((x) => x)), + "amphithyron": List.from(amphithyron.map((x) => x?.toJson())), + "Andriana": List.from(andriana.map((x) => x)), + "ankee": List.from(ankee.map((x) => x)), + "annihilator": List.from(annihilator.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "annulose": annulose, + "Ansarie": List.from(ansarie.map((x) => x)), + "aphasia": List.from(aphasia.map((x) => x)), + "asprawl": List.from(asprawl.map((x) => x)), + "attractive": List.from(attractive.map((x) => x)), + "barksome": Map.from(barksome).map((k, v) => MapEntry(k, v)), + "bedesman": List.from(bedesman.map((x) => x)), + "belard": List.from(belard.map((x) => x)), + "bocking": List.from(bocking.map((x) => x)), + "brawlingly": List.from(brawlingly.map((x) => x)), + "brookie": List.from(brookie.map((x) => x)), + "bumboatman": List.from(bumboatman.map((x) => x)), + "bystreet": List.from(bystreet.map((x) => x)), + "calaverite": List.from(calaverite.map((x) => x)), + "catallactic": List.from(catallactic.map((x) => x)), + "cemental": List.from(cemental.map((x) => x)), + "Chytridiaceae": List.from(chytridiaceae.map((x) => x)), + "Discordia": List.from(discordia.map((x) => x)), + "Endomyces": List.from(endomyces.map((x) => x)), + "Epinephelidae": List.from(epinephelidae.map((x) => x)), + "Eupatorium": List.from(eupatorium.map((x) => x)), + "Gryphosaurus": List.from(gryphosaurus.map((x) => x)), + "Koryak": List.from(koryak.map((x) => x)), + "Lavinia": List.from(lavinia.map((x) => x)), + "Oskar": List.from(oskar.map((x) => x)), + "Rebecca": List.from(rebecca.map((x) => x)), + "Rhomboganoidei": List.from(rhomboganoidei.map((x) => x)), + "Rigsmal": rigsmal, + "Ruellia": List.from(ruellia.map((x) => x)), + "School": List.from(school.map((x) => x)), + "Shakespearolater": List.from(shakespearolater.map((x) => x)), + "Svan": List.from(svan.map((x) => x)), + "Wayao": Map.from(wayao).map((k, v) => MapEntry(k, v)), + }; +} + +class AlleviateClass { + dynamic apriori; + dynamic beggarer; + dynamic brokenheartedly; + dynamic debilitation; + dynamic frike; + dynamic gastrolith; + dynamic hulsean; + dynamic orthocentric; + dynamic petaly; + dynamic probudgeting; + dynamic reacquire; + dynamic scow; + dynamic shutoff; + dynamic subcontiguous; + dynamic suffumigate; + dynamic transformable; + dynamic uncoroneted; + dynamic unparking; + dynamic unvarnishedness; + dynamic wherewithal; + + AlleviateClass({ + required this.apriori, + required this.beggarer, + required this.brokenheartedly, + required this.debilitation, + required this.frike, + required this.gastrolith, + required this.hulsean, + required this.orthocentric, + required this.petaly, + required this.probudgeting, + required this.reacquire, + required this.scow, + required this.shutoff, + required this.subcontiguous, + required this.suffumigate, + required this.transformable, + required this.uncoroneted, + required this.unparking, + required this.unvarnishedness, + required this.wherewithal, + }); + + factory AlleviateClass.fromJson(Map json) => AlleviateClass( + apriori: json["apriori"], + beggarer: json["beggarer"], + brokenheartedly: json["brokenheartedly"], + debilitation: json["debilitation"], + frike: json["frike"], + gastrolith: json["gastrolith"], + hulsean: json["Hulsean"], + orthocentric: json["orthocentric"], + petaly: json["petaly"], + probudgeting: json["probudgeting"], + reacquire: json["reacquire"], + scow: json["scow"], + shutoff: json["shutoff"], + subcontiguous: json["subcontiguous"], + suffumigate: json["suffumigate"], + transformable: json["transformable"], + uncoroneted: json["uncoroneted"], + unparking: json["unparking"], + unvarnishedness: json["unvarnishedness"], + wherewithal: json["wherewithal"], + ); + + Map toJson() => { + "apriori": apriori, + "beggarer": beggarer, + "brokenheartedly": brokenheartedly, + "debilitation": debilitation, + "frike": frike, + "gastrolith": gastrolith, + "Hulsean": hulsean, + "orthocentric": orthocentric, + "petaly": petaly, + "probudgeting": probudgeting, + "reacquire": reacquire, + "scow": scow, + "shutoff": shutoff, + "subcontiguous": subcontiguous, + "suffumigate": suffumigate, + "transformable": transformable, + "uncoroneted": uncoroneted, + "unparking": unparking, + "unvarnishedness": unvarnishedness, + "wherewithal": wherewithal, + }; +} + +class Rebecca { + double catharticalness; + int chirotherium; + String disdiapason; + bool homocerc; + dynamic nonbookish; + + Rebecca({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory Rebecca.fromJson(Map json) => Rebecca( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: json["nonbookish"], + ); + + Map toJson() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Amphithyron { + int? akroasis; + int? antiphonical; + int? basebred; + double? catharticalness; + int? chirotherium; + int? conductometric; + String? disdiapason; + int? ensilation; + int? eyebolt; + int? fistulated; + int? heteropod; + bool? homocerc; + int? juniperus; + int? labyrinthically; + int? martyrization; + int? mispolicy; + int? multipara; + int? nazirite; + dynamic nonbookish; + int? possessorial; + int? shamed; + int? shelfworn; + int? stagnum; + int? those; + int? undecimal; + + Amphithyron({ + this.akroasis, + this.antiphonical, + this.basebred, + this.catharticalness, + this.chirotherium, + this.conductometric, + this.disdiapason, + this.ensilation, + this.eyebolt, + this.fistulated, + this.heteropod, + this.homocerc, + this.juniperus, + this.labyrinthically, + this.martyrization, + this.mispolicy, + this.multipara, + this.nazirite, + this.nonbookish, + this.possessorial, + this.shamed, + this.shelfworn, + this.stagnum, + this.those, + this.undecimal, + }); + + factory Amphithyron.fromJson(Map json) => Amphithyron( + akroasis: json["akroasis"], + antiphonical: json["antiphonical"], + basebred: json["basebred"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + conductometric: json["conductometric"], + disdiapason: json["disdiapason"], + ensilation: json["ensilation"], + eyebolt: json["eyebolt"], + fistulated: json["fistulated"], + heteropod: json["heteropod"], + homocerc: json["homocerc"], + juniperus: json["Juniperus"], + labyrinthically: json["labyrinthically"], + martyrization: json["martyrization"], + mispolicy: json["mispolicy"], + multipara: json["multipara"], + nazirite: json["Nazirite"], + nonbookish: json["nonbookish"], + possessorial: json["possessorial"], + shamed: json["shamed"], + shelfworn: json["shelfworn"], + stagnum: json["stagnum"], + those: json["Those"], + undecimal: json["undecimal"], + ); + + Map toJson() => { + "akroasis": akroasis, + "antiphonical": antiphonical, + "basebred": basebred, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "conductometric": conductometric, + "disdiapason": disdiapason, + "ensilation": ensilation, + "eyebolt": eyebolt, + "fistulated": fistulated, + "heteropod": heteropod, + "homocerc": homocerc, + "Juniperus": juniperus, + "labyrinthically": labyrinthically, + "martyrization": martyrization, + "mispolicy": mispolicy, + "multipara": multipara, + "Nazirite": nazirite, + "nonbookish": nonbookish, + "possessorial": possessorial, + "shamed": shamed, + "shelfworn": shelfworn, + "stagnum": stagnum, + "Those": those, + "undecimal": undecimal, + }; +} + +class AnkeeClass { + dynamic anomoean; + dynamic barleyhood; + dynamic befriender; + dynamic brutishness; + dynamic cephalalgy; + dynamic cirurgian; + dynamic conventionally; + dynamic jackshay; + dynamic milammeter; + dynamic naja; + dynamic ombrological; + dynamic phonasthenia; + dynamic retrievableness; + dynamic snakily; + dynamic swot; + dynamic tartlet; + dynamic thiofuran; + dynamic tracheophone; + dynamic tuglike; + dynamic unscratchingly; + + AnkeeClass({ + required this.anomoean, + required this.barleyhood, + required this.befriender, + required this.brutishness, + required this.cephalalgy, + required this.cirurgian, + required this.conventionally, + required this.jackshay, + required this.milammeter, + required this.naja, + required this.ombrological, + required this.phonasthenia, + required this.retrievableness, + required this.snakily, + required this.swot, + required this.tartlet, + required this.thiofuran, + required this.tracheophone, + required this.tuglike, + required this.unscratchingly, + }); + + factory AnkeeClass.fromJson(Map json) => AnkeeClass( + anomoean: json["Anomoean"], + barleyhood: json["barleyhood"], + befriender: json["befriender"], + brutishness: json["brutishness"], + cephalalgy: json["cephalalgy"], + cirurgian: json["cirurgian"], + conventionally: json["conventionally"], + jackshay: json["jackshay"], + milammeter: json["milammeter"], + naja: json["Naja"], + ombrological: json["ombrological"], + phonasthenia: json["phonasthenia"], + retrievableness: json["retrievableness"], + snakily: json["snakily"], + swot: json["swot"], + tartlet: json["tartlet"], + thiofuran: json["thiofuran"], + tracheophone: json["tracheophone"], + tuglike: json["tuglike"], + unscratchingly: json["unscratchingly"], + ); + + Map toJson() => { + "Anomoean": anomoean, + "barleyhood": barleyhood, + "befriender": befriender, + "brutishness": brutishness, + "cephalalgy": cephalalgy, + "cirurgian": cirurgian, + "conventionally": conventionally, + "jackshay": jackshay, + "milammeter": milammeter, + "Naja": naja, + "ombrological": ombrological, + "phonasthenia": phonasthenia, + "retrievableness": retrievableness, + "snakily": snakily, + "swot": swot, + "tartlet": tartlet, + "thiofuran": thiofuran, + "tracheophone": tracheophone, + "tuglike": tuglike, + "unscratchingly": unscratchingly, + }; +} + +class AnsarieClass { + dynamic accension; + dynamic alida; + dynamic asteria; + dynamic beriberic; + dynamic edgebone; + dynamic gastrodialysis; + dynamic geographic; + dynamic ictonyx; + dynamic metrocele; + dynamic misgraft; + dynamic monteith; + dynamic notcher; + dynamic prorestriction; + dynamic ramist; + dynamic throatlet; + dynamic unfair; + dynamic unsynonymous; + dynamic water; + dynamic zestfully; + dynamic zincic; + + AnsarieClass({ + required this.accension, + required this.alida, + required this.asteria, + required this.beriberic, + required this.edgebone, + required this.gastrodialysis, + required this.geographic, + required this.ictonyx, + required this.metrocele, + required this.misgraft, + required this.monteith, + required this.notcher, + required this.prorestriction, + required this.ramist, + required this.throatlet, + required this.unfair, + required this.unsynonymous, + required this.water, + required this.zestfully, + required this.zincic, + }); + + factory AnsarieClass.fromJson(Map json) => AnsarieClass( + accension: json["accension"], + alida: json["Alida"], + asteria: json["asteria"], + beriberic: json["beriberic"], + edgebone: json["edgebone"], + gastrodialysis: json["gastrodialysis"], + geographic: json["geographic"], + ictonyx: json["Ictonyx"], + metrocele: json["metrocele"], + misgraft: json["misgraft"], + monteith: json["monteith"], + notcher: json["notcher"], + prorestriction: json["prorestriction"], + ramist: json["Ramist"], + throatlet: json["throatlet"], + unfair: json["unfair"], + unsynonymous: json["unsynonymous"], + water: json["water"], + zestfully: json["zestfully"], + zincic: json["zincic"], + ); + + Map toJson() => { + "accension": accension, + "Alida": alida, + "asteria": asteria, + "beriberic": beriberic, + "edgebone": edgebone, + "gastrodialysis": gastrodialysis, + "geographic": geographic, + "Ictonyx": ictonyx, + "metrocele": metrocele, + "misgraft": misgraft, + "monteith": monteith, + "notcher": notcher, + "prorestriction": prorestriction, + "Ramist": ramist, + "throatlet": throatlet, + "unfair": unfair, + "unsynonymous": unsynonymous, + "water": water, + "zestfully": zestfully, + "zincic": zincic, + }; +} + +class ChytridiaceaeClass { + dynamic batidaceae; + dynamic brechites; + dynamic codespairer; + dynamic emery; + dynamic enervative; + dynamic excriminate; + dynamic goshenite; + dynamic grime; + dynamic gritten; + dynamic hectorly; + dynamic intermediation; + dynamic meeterly; + dynamic narraganset; + dynamic onymatic; + dynamic paddlecock; + dynamic thana; + dynamic thornily; + dynamic uckia; + dynamic unmettle; + dynamic vorticellid; + + ChytridiaceaeClass({ + required this.batidaceae, + required this.brechites, + required this.codespairer, + required this.emery, + required this.enervative, + required this.excriminate, + required this.goshenite, + required this.grime, + required this.gritten, + required this.hectorly, + required this.intermediation, + required this.meeterly, + required this.narraganset, + required this.onymatic, + required this.paddlecock, + required this.thana, + required this.thornily, + required this.uckia, + required this.unmettle, + required this.vorticellid, + }); + + factory ChytridiaceaeClass.fromJson(Map json) => ChytridiaceaeClass( + batidaceae: json["Batidaceae"], + brechites: json["Brechites"], + codespairer: json["codespairer"], + emery: json["Emery"], + enervative: json["enervative"], + excriminate: json["excriminate"], + goshenite: json["goshenite"], + grime: json["grime"], + gritten: json["gritten"], + hectorly: json["hectorly"], + intermediation: json["intermediation"], + meeterly: json["meeterly"], + narraganset: json["Narraganset"], + onymatic: json["onymatic"], + paddlecock: json["paddlecock"], + thana: json["thana"], + thornily: json["thornily"], + uckia: json["uckia"], + unmettle: json["unmettle"], + vorticellid: json["vorticellid"], + ); + + Map toJson() => { + "Batidaceae": batidaceae, + "Brechites": brechites, + "codespairer": codespairer, + "Emery": emery, + "enervative": enervative, + "excriminate": excriminate, + "goshenite": goshenite, + "grime": grime, + "gritten": gritten, + "hectorly": hectorly, + "intermediation": intermediation, + "meeterly": meeterly, + "Narraganset": narraganset, + "onymatic": onymatic, + "paddlecock": paddlecock, + "thana": thana, + "thornily": thornily, + "uckia": uckia, + "unmettle": unmettle, + "vorticellid": vorticellid, + }; +} + +class DiscordiaClass { + int? altaic; + int? amoristic; + int? blennophthalmia; + double? catharticalness; + int? chirotherium; + int? disciplinability; + String? disdiapason; + int? goofer; + bool? homocerc; + int? laryngograph; + int? leucitis; + int? lymphocyst; + int? microcosmology; + int? nauseation; + dynamic nonbookish; + int? patarin; + int? preliberal; + int? prettifier; + int? rangework; + int? redient; + int? subfusiform; + int? suicidical; + int? swow; + int? wastrel; + int? wingle; + + DiscordiaClass({ + this.altaic, + this.amoristic, + this.blennophthalmia, + this.catharticalness, + this.chirotherium, + this.disciplinability, + this.disdiapason, + this.goofer, + this.homocerc, + this.laryngograph, + this.leucitis, + this.lymphocyst, + this.microcosmology, + this.nauseation, + this.nonbookish, + this.patarin, + this.preliberal, + this.prettifier, + this.rangework, + this.redient, + this.subfusiform, + this.suicidical, + this.swow, + this.wastrel, + this.wingle, + }); + + factory DiscordiaClass.fromJson(Map json) => DiscordiaClass( + altaic: json["Altaic"], + amoristic: json["amoristic"], + blennophthalmia: json["blennophthalmia"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disciplinability: json["disciplinability"], + disdiapason: json["disdiapason"], + goofer: json["goofer"], + homocerc: json["homocerc"], + laryngograph: json["laryngograph"], + leucitis: json["leucitis"], + lymphocyst: json["lymphocyst"], + microcosmology: json["microcosmology"], + nauseation: json["nauseation"], + nonbookish: json["nonbookish"], + patarin: json["Patarin"], + preliberal: json["preliberal"], + prettifier: json["prettifier"], + rangework: json["rangework"], + redient: json["redient"], + subfusiform: json["subfusiform"], + suicidical: json["suicidical"], + swow: json["swow"], + wastrel: json["wastrel"], + wingle: json["wingle"], + ); + + Map toJson() => { + "Altaic": altaic, + "amoristic": amoristic, + "blennophthalmia": blennophthalmia, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disciplinability": disciplinability, + "disdiapason": disdiapason, + "goofer": goofer, + "homocerc": homocerc, + "laryngograph": laryngograph, + "leucitis": leucitis, + "lymphocyst": lymphocyst, + "microcosmology": microcosmology, + "nauseation": nauseation, + "nonbookish": nonbookish, + "Patarin": patarin, + "preliberal": preliberal, + "prettifier": prettifier, + "rangework": rangework, + "redient": redient, + "subfusiform": subfusiform, + "suicidical": suicidical, + "swow": swow, + "wastrel": wastrel, + "wingle": wingle, + }; +} + +class GryphosaurusClass { + dynamic amissibility; + dynamic burushaski; + dynamic citronin; + dynamic coplaintiff; + dynamic disquisitionary; + dynamic enoplan; + dynamic faintness; + dynamic hebetomy; + dynamic islandry; + dynamic lameduck; + dynamic overbattle; + dynamic overinterested; + dynamic phrenologic; + dynamic rainband; + dynamic shiningly; + dynamic stamineous; + dynamic subscapularis; + dynamic tahami; + dynamic undaubed; + dynamic underntime; + + GryphosaurusClass({ + required this.amissibility, + required this.burushaski, + required this.citronin, + required this.coplaintiff, + required this.disquisitionary, + required this.enoplan, + required this.faintness, + required this.hebetomy, + required this.islandry, + required this.lameduck, + required this.overbattle, + required this.overinterested, + required this.phrenologic, + required this.rainband, + required this.shiningly, + required this.stamineous, + required this.subscapularis, + required this.tahami, + required this.undaubed, + required this.underntime, + }); + + factory GryphosaurusClass.fromJson(Map json) => GryphosaurusClass( + amissibility: json["amissibility"], + burushaski: json["Burushaski"], + citronin: json["citronin"], + coplaintiff: json["coplaintiff"], + disquisitionary: json["disquisitionary"], + enoplan: json["enoplan"], + faintness: json["faintness"], + hebetomy: json["hebetomy"], + islandry: json["islandry"], + lameduck: json["lameduck"], + overbattle: json["overbattle"], + overinterested: json["overinterested"], + phrenologic: json["phrenologic"], + rainband: json["rainband"], + shiningly: json["shiningly"], + stamineous: json["stamineous"], + subscapularis: json["subscapularis"], + tahami: json["Tahami"], + undaubed: json["undaubed"], + underntime: json["underntime"], + ); + + Map toJson() => { + "amissibility": amissibility, + "Burushaski": burushaski, + "citronin": citronin, + "coplaintiff": coplaintiff, + "disquisitionary": disquisitionary, + "enoplan": enoplan, + "faintness": faintness, + "hebetomy": hebetomy, + "islandry": islandry, + "lameduck": lameduck, + "overbattle": overbattle, + "overinterested": overinterested, + "phrenologic": phrenologic, + "rainband": rainband, + "shiningly": shiningly, + "stamineous": stamineous, + "subscapularis": subscapularis, + "Tahami": tahami, + "undaubed": undaubed, + "underntime": underntime, + }; +} + +class LaviniaClass { + int? agitable; + int? asininity; + int? benefiter; + int? bronzelike; + double? catharticalness; + int? chirotherium; + int? cholesteatomatous; + int? deprivement; + String? disdiapason; + int? flippantness; + int? fogproof; + bool? homocerc; + int? merrymeeting; + dynamic nonbookish; + int? overcareful; + int? panaris; + int? preacceptance; + int? quinoxaline; + int? sig; + int? superconfusion; + int? tacana; + int? tillotter; + int? tranquillize; + int? unquestionable; + int? uproute; + + LaviniaClass({ + this.agitable, + this.asininity, + this.benefiter, + this.bronzelike, + this.catharticalness, + this.chirotherium, + this.cholesteatomatous, + this.deprivement, + this.disdiapason, + this.flippantness, + this.fogproof, + this.homocerc, + this.merrymeeting, + this.nonbookish, + this.overcareful, + this.panaris, + this.preacceptance, + this.quinoxaline, + this.sig, + this.superconfusion, + this.tacana, + this.tillotter, + this.tranquillize, + this.unquestionable, + this.uproute, + }); + + factory LaviniaClass.fromJson(Map json) => LaviniaClass( + agitable: json["agitable"], + asininity: json["asininity"], + benefiter: json["benefiter"], + bronzelike: json["bronzelike"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cholesteatomatous: json["cholesteatomatous"], + deprivement: json["deprivement"], + disdiapason: json["disdiapason"], + flippantness: json["flippantness"], + fogproof: json["fogproof"], + homocerc: json["homocerc"], + merrymeeting: json["merrymeeting"], + nonbookish: json["nonbookish"], + overcareful: json["overcareful"], + panaris: json["panaris"], + preacceptance: json["preacceptance"], + quinoxaline: json["quinoxaline"], + sig: json["sig"], + superconfusion: json["superconfusion"], + tacana: json["Tacana"], + tillotter: json["tillotter"], + tranquillize: json["tranquillize"], + unquestionable: json["unquestionable"], + uproute: json["uproute"], + ); + + Map toJson() => { + "agitable": agitable, + "asininity": asininity, + "benefiter": benefiter, + "bronzelike": bronzelike, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cholesteatomatous": cholesteatomatous, + "deprivement": deprivement, + "disdiapason": disdiapason, + "flippantness": flippantness, + "fogproof": fogproof, + "homocerc": homocerc, + "merrymeeting": merrymeeting, + "nonbookish": nonbookish, + "overcareful": overcareful, + "panaris": panaris, + "preacceptance": preacceptance, + "quinoxaline": quinoxaline, + "sig": sig, + "superconfusion": superconfusion, + "Tacana": tacana, + "tillotter": tillotter, + "tranquillize": tranquillize, + "unquestionable": unquestionable, + "uproute": uproute, + }; +} + +class OskarClass { + dynamic acrobates; + dynamic beanshooter; + dynamic bearhound; + dynamic cayuga; + dynamic guarneri; + dynamic hypochondriacism; + dynamic indication; + dynamic jaculative; + dynamic nagana; + dynamic netherlandish; + dynamic noctivagous; + dynamic nonphysiological; + dynamic praxis; + dynamic provision; + dynamic subterhuman; + dynamic sunlit; + dynamic syncraniate; + dynamic teachment; + dynamic unmutinous; + dynamic unstoppable; + + OskarClass({ + required this.acrobates, + required this.beanshooter, + required this.bearhound, + required this.cayuga, + required this.guarneri, + required this.hypochondriacism, + required this.indication, + required this.jaculative, + required this.nagana, + required this.netherlandish, + required this.noctivagous, + required this.nonphysiological, + required this.praxis, + required this.provision, + required this.subterhuman, + required this.sunlit, + required this.syncraniate, + required this.teachment, + required this.unmutinous, + required this.unstoppable, + }); + + factory OskarClass.fromJson(Map json) => OskarClass( + acrobates: json["Acrobates"], + beanshooter: json["beanshooter"], + bearhound: json["bearhound"], + cayuga: json["Cayuga"], + guarneri: json["guarneri"], + hypochondriacism: json["hypochondriacism"], + indication: json["indication"], + jaculative: json["jaculative"], + nagana: json["nagana"], + netherlandish: json["Netherlandish"], + noctivagous: json["noctivagous"], + nonphysiological: json["nonphysiological"], + praxis: json["praxis"], + provision: json["provision"], + subterhuman: json["subterhuman"], + sunlit: json["sunlit"], + syncraniate: json["syncraniate"], + teachment: json["teachment"], + unmutinous: json["unmutinous"], + unstoppable: json["unstoppable"], + ); + + Map toJson() => { + "Acrobates": acrobates, + "beanshooter": beanshooter, + "bearhound": bearhound, + "Cayuga": cayuga, + "guarneri": guarneri, + "hypochondriacism": hypochondriacism, + "indication": indication, + "jaculative": jaculative, + "nagana": nagana, + "Netherlandish": netherlandish, + "noctivagous": noctivagous, + "nonphysiological": nonphysiological, + "praxis": praxis, + "provision": provision, + "subterhuman": subterhuman, + "sunlit": sunlit, + "syncraniate": syncraniate, + "teachment": teachment, + "unmutinous": unmutinous, + "unstoppable": unstoppable, + }; +} diff --git a/base/schema-dart/test/inputs/schema/class-map-union.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/class-map-union.schema/default/TopLevel.dart index 4d26de0..11220d9 100644 --- a/base/schema-dart/test/inputs/schema/class-map-union.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/class-map-union.schema/default/TopLevel.dart @@ -16,11 +16,11 @@ class TopLevel { }); factory TopLevel.fromJson(Map json) => TopLevel( - union: Map.from(json["union"]!).map((k, v) => MapEntry(k, v)), + union: json["union"] == null ? null : Map.from(json["union"]!).map((k, v) => MapEntry(k, v)), ); Map toJson() => { - "union": Map.from(union!).map((k, v) => MapEntry(k, v)), + "union": union == null ? null : Map.from(union!).map((k, v) => MapEntry(k, v)), }; } diff --git a/base/schema-dart/test/inputs/schema/class-with-additional.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/class-with-additional.schema/default/TopLevel.dart index 4f40c88..fb27cdb 100644 --- a/base/schema-dart/test/inputs/schema/class-with-additional.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/class-with-additional.schema/default/TopLevel.dart @@ -16,10 +16,10 @@ class TopLevel { }); factory TopLevel.fromJson(Map json) => TopLevel( - map: Map.from(json["map"]!).map((k, v) => MapEntry(k, v)), + map: json["map"] == null ? null : Map.from(json["map"]!).map((k, v) => MapEntry(k, v)), ); Map toJson() => { - "map": Map.from(map!).map((k, v) => MapEntry(k, v)), + "map": map == null ? null : Map.from(map!).map((k, v) => MapEntry(k, v)), }; } diff --git a/base/schema-dart/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.dart index 7abcf39..33e2c1a 100644 --- a/base/schema-dart/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.dart @@ -38,13 +38,13 @@ class Config { factory Config.fromJson(Map json) => Config( closed: json["closed"], name: json["name"], - settings: Map.from(json["settings"]!).map((k, v) => MapEntry>(k, List.from(v.map((x) => Item.fromJson(x))))), + settings: json["settings"] == null ? null : Map.from(json["settings"]!).map((k, v) => MapEntry>(k, List.from(v.map((x) => Item.fromJson(x))))), ); Map toJson() => { "closed": closed, "name": name, - "settings": Map.from(settings!).map((k, v) => MapEntry(k, List.from(v.map((x) => x.toJson())))), + "settings": settings == null ? null : Map.from(settings!).map((k, v) => MapEntry(k, List.from(v.map((x) => x.toJson())))), }; } diff --git a/base/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart index e65602f..2a15c49 100644 --- a/base/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart @@ -189,7 +189,7 @@ class TopLevel { name: json["name"], padding: json["padding"], projection: json["projection"] == null ? null : Projection.fromJson(json["projection"]), - selection: Map.from(json["selection"]!).map((k, v) => MapEntry(k, SelectionDef.fromJson(v))), + selection: json["selection"] == null ? null : Map.from(json["selection"]!).map((k, v) => MapEntry(k, SelectionDef.fromJson(v))), title: json["title"], transform: json["transform"] == null ? null : List.from(json["transform"]!.map((x) => Transform.fromJson(x))), width: json["width"]?.toDouble(), @@ -215,7 +215,7 @@ class TopLevel { "name": name, "padding": padding, "projection": projection?.toJson(), - "selection": Map.from(selection!).map((k, v) => MapEntry(k, v.toJson())), + "selection": selection == null ? null : Map.from(selection!).map((k, v) => MapEntry(k, v.toJson())), "title": title, "transform": transform == null ? null : List.from(transform!.map((x) => x.toJson())), "width": width, @@ -534,14 +534,14 @@ class Config { padding: json["padding"], point: json["point"] == null ? null : MarkConfig.fromJson(json["point"]), projection: json["projection"] == null ? null : ProjectionConfig.fromJson(json["projection"]), - range: Map.from(json["range"]!).map((k, v) => MapEntry(k, v)), + range: json["range"] == null ? null : Map.from(json["range"]!).map((k, v) => MapEntry(k, v)), rect: json["rect"] == null ? null : MarkConfig.fromJson(json["rect"]), rule: json["rule"] == null ? null : MarkConfig.fromJson(json["rule"]), scale: json["scale"] == null ? null : ScaleConfig.fromJson(json["scale"]), selection: json["selection"] == null ? null : SelectionConfig.fromJson(json["selection"]), square: json["square"] == null ? null : MarkConfig.fromJson(json["square"]), stack: stackOffsetValues.map[json["stack"]], - style: Map.from(json["style"]!).map((k, v) => MapEntry(k, VgMarkConfig.fromJson(v))), + style: json["style"] == null ? null : Map.from(json["style"]!).map((k, v) => MapEntry(k, VgMarkConfig.fromJson(v))), text: json["text"] == null ? null : TextConfig.fromJson(json["text"]), tick: json["tick"] == null ? null : TickConfig.fromJson(json["tick"]), timeFormat: json["timeFormat"], @@ -574,14 +574,14 @@ class Config { "padding": padding, "point": point?.toJson(), "projection": projection?.toJson(), - "range": Map.from(range!).map((k, v) => MapEntry(k, v)), + "range": range == null ? null : Map.from(range!).map((k, v) => MapEntry(k, v)), "rect": rect?.toJson(), "rule": rule?.toJson(), "scale": scale?.toJson(), "selection": selection?.toJson(), "square": square?.toJson(), "stack": stackOffsetValues.reverse[stack], - "style": Map.from(style!).map((k, v) => MapEntry(k, v.toJson())), + "style": style == null ? null : Map.from(style!).map((k, v) => MapEntry(k, v.toJson())), "text": text?.toJson(), "tick": tick?.toJson(), "timeFormat": timeFormat, @@ -2376,7 +2376,7 @@ class ProjectionConfig { fraction: json["fraction"]?.toDouble(), lobes: json["lobes"]?.toDouble(), parallel: json["parallel"]?.toDouble(), - precision: Map.from(json["precision"]!).map((k, v) => MapEntry(k, v)), + precision: json["precision"] == null ? null : Map.from(json["precision"]!).map((k, v) => MapEntry(k, v)), radius: json["radius"]?.toDouble(), ratio: json["ratio"]?.toDouble(), rotate: json["rotate"] == null ? null : List.from(json["rotate"]!.map((x) => x?.toDouble())), @@ -2394,7 +2394,7 @@ class ProjectionConfig { "fraction": fraction, "lobes": lobes, "parallel": parallel, - "precision": Map.from(precision!).map((k, v) => MapEntry(k, v)), + "precision": precision == null ? null : Map.from(precision!).map((k, v) => MapEntry(k, v)), "radius": radius, "ratio": ratio, "rotate": rotate == null ? null : List.from(rotate!.map((x) => x)), @@ -3067,7 +3067,7 @@ class SingleSelectionConfig { }); factory SingleSelectionConfig.fromJson(Map json) => SingleSelectionConfig( - bind: Map.from(json["bind"]!).map((k, v) => MapEntry(k, VgBinding.fromJson(v))), + bind: json["bind"] == null ? null : Map.from(json["bind"]!).map((k, v) => MapEntry(k, VgBinding.fromJson(v))), empty: emptyValues.map[json["empty"]], encodings: json["encodings"] == null ? null : List.from(json["encodings"]!.map((x) => singleDefChannelValues.map[x]!)), fields: json["fields"] == null ? null : List.from(json["fields"]!.map((x) => x)), @@ -3077,7 +3077,7 @@ class SingleSelectionConfig { ); Map toJson() => { - "bind": Map.from(bind!).map((k, v) => MapEntry(k, v.toJson())), + "bind": bind == null ? null : Map.from(bind!).map((k, v) => MapEntry(k, v.toJson())), "empty": emptyValues.reverse[empty], "encodings": encodings == null ? null : List.from(encodings!.map((x) => singleDefChannelValues.reverse[x])), "fields": fields == null ? null : List.from(fields!.map((x) => x)), @@ -7050,7 +7050,7 @@ class Spec { encoding: json["encoding"] == null ? null : Encoding.fromJson(json["encoding"]), mark: json["mark"], projection: json["projection"] == null ? null : Projection.fromJson(json["projection"]), - selection: Map.from(json["selection"]!).map((k, v) => MapEntry(k, SelectionDef.fromJson(v))), + selection: json["selection"] == null ? null : Map.from(json["selection"]!).map((k, v) => MapEntry(k, SelectionDef.fromJson(v))), facet: json["facet"] == null ? null : FacetMapping.fromJson(json["facet"]), spec: json["spec"] == null ? null : Spec.fromJson(json["spec"]), repeat: json["repeat"] == null ? null : Repeat.fromJson(json["repeat"]), @@ -7071,7 +7071,7 @@ class Spec { "encoding": encoding?.toJson(), "mark": mark, "projection": projection?.toJson(), - "selection": Map.from(selection!).map((k, v) => MapEntry(k, v.toJson())), + "selection": selection == null ? null : Map.from(selection!).map((k, v) => MapEntry(k, v.toJson())), "facet": facet?.toJson(), "spec": spec?.toJson(), "repeat": repeat?.toJson(), @@ -7314,7 +7314,7 @@ class LayerSpec { encoding: json["encoding"] == null ? null : Encoding.fromJson(json["encoding"]), mark: json["mark"], projection: json["projection"] == null ? null : Projection.fromJson(json["projection"]), - selection: Map.from(json["selection"]!).map((k, v) => MapEntry(k, SelectionDef.fromJson(v))), + selection: json["selection"] == null ? null : Map.from(json["selection"]!).map((k, v) => MapEntry(k, SelectionDef.fromJson(v))), ); Map toJson() => { @@ -7330,7 +7330,7 @@ class LayerSpec { "encoding": encoding?.toJson(), "mark": mark, "projection": projection?.toJson(), - "selection": Map.from(selection!).map((k, v) => MapEntry(k, v.toJson())), + "selection": selection == null ? null : Map.from(selection!).map((k, v) => MapEntry(k, v.toJson())), }; } @@ -7737,7 +7737,7 @@ class Projection { fraction: json["fraction"]?.toDouble(), lobes: json["lobes"]?.toDouble(), parallel: json["parallel"]?.toDouble(), - precision: Map.from(json["precision"]!).map((k, v) => MapEntry(k, v)), + precision: json["precision"] == null ? null : Map.from(json["precision"]!).map((k, v) => MapEntry(k, v)), radius: json["radius"]?.toDouble(), ratio: json["ratio"]?.toDouble(), rotate: json["rotate"] == null ? null : List.from(json["rotate"]!.map((x) => x?.toDouble())), @@ -7755,7 +7755,7 @@ class Projection { "fraction": fraction, "lobes": lobes, "parallel": parallel, - "precision": Map.from(precision!).map((k, v) => MapEntry(k, v)), + "precision": precision == null ? null : Map.from(precision!).map((k, v) => MapEntry(k, v)), "radius": radius, "ratio": ratio, "rotate": rotate == null ? null : List.from(rotate!.map((x) => x)),