diff --git a/head/csharp/test/inputs/json/priority/combinations1.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs b/head/csharp/test/inputs/json/priority/combinations1.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs
new file mode 100644
index 0000000..aec12eb
--- /dev/null
+++ b/head/csharp/test/inputs/json/priority/combinations1.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs
@@ -0,0 +1,2712 @@
+//
+//
+// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
+//
+// using QuickType;
+//
+// var topLevel = TopLevel.FromJson(jsonString);
+#nullable enable
+#pragma warning disable CS8618
+#pragma warning disable CS8601
+#pragma warning disable CS8602
+#pragma warning disable CS8603
+#pragma warning disable CS8604
+#pragma warning disable CS8625
+#pragma warning disable CS8765
+
+namespace QuickType
+{
+ using System;
+ using System.Collections.Generic;
+
+ using System.Globalization;
+ using Newtonsoft.Json;
+ using Newtonsoft.Json.Converters;
+
+ public partial class TopLevel
+ {
+ [JsonProperty("centrodesmose", Required = Required.Always)]
+ public string Centrodesmose { get; set; }
+
+ [JsonProperty("cerograph", Required = Required.Always)]
+ public CerographElement[] Cerograph { get; set; }
+
+ [JsonProperty("chemotherapeutics", Required = Required.Always)]
+ public ChemotherapeuticElement[] Chemotherapeutics { get; set; }
+
+ [JsonProperty("cimelia", Required = Required.Always)]
+ public CimeliaElement[] Cimelia { get; set; }
+
+ [JsonProperty("citrated", Required = Required.Always)]
+ public long Citrated { get; set; }
+
+ [JsonProperty("clinodome", Required = Required.Always)]
+ public Clinodome[] Clinodome { get; set; }
+
+ [JsonProperty("coadjust", Required = Required.Always)]
+ public CoadjustElement[] Coadjust { get; set; }
+
+ [JsonProperty("consilience", Required = Required.Always)]
+ public Consilience[] Consilience { get; set; }
+
+ [JsonProperty("constructor", Required = Required.Always)]
+ public Constructor[] Constructor { get; set; }
+
+ [JsonProperty("continuative", Required = Required.Always)]
+ public Continuative[] Continuative { get; set; }
+
+ [JsonProperty("credulity", Required = Required.Always)]
+ public CredulityElement[] Credulity { get; set; }
+
+ [JsonProperty("creviced", Required = Required.Always)]
+ public Creviced[] Creviced { get; set; }
+
+ [JsonProperty("cubiculum", Required = Required.Always)]
+ public long?[][] Cubiculum { get; set; }
+
+ [JsonProperty("deruralize", Required = Required.Always)]
+ public DeruralizeElement[] Deruralize { get; set; }
+
+ [JsonProperty("diaereses", Required = Required.Always)]
+ public DiaereseElement[] Diaereses { get; set; }
+
+ [JsonProperty("dissolution", Required = Required.Always)]
+ public object[]?[] Dissolution { get; set; }
+
+ [JsonProperty("downstroke", Required = Required.Always)]
+ public Downstroke[] Downstroke { get; set; }
+
+ [JsonProperty("electrotautomerism", Required = Required.Always)]
+ public double?[] Electrotautomerism { get; set; }
+
+ [JsonProperty("eleutheromania", Required = Required.Always)]
+ public Eleutheromania[] Eleutheromania { get; set; }
+
+ [JsonProperty("encrust", Required = Required.Always)]
+ public Encrust Encrust { get; set; }
+
+ [JsonProperty("entomoid", Required = Required.Always)]
+ public Entomoid[] Entomoid { get; set; }
+
+ [JsonProperty("epipaleolithic", Required = Required.Always)]
+ public Epipaleolithic[] Epipaleolithic { get; set; }
+
+ [JsonProperty("expropriable", Required = Required.Always)]
+ public Expropriable[] Expropriable { get; set; }
+
+ [JsonProperty("faggingly", Required = Required.Always)]
+ public FagginglyElement[] Faggingly { get; set; }
+
+ [JsonProperty("fenks", Required = Required.Always)]
+ public FenkElement[] Fenks { get; set; }
+
+ [JsonProperty("flagmaking", Required = Required.Always)]
+ public FlagmakingElement[] Flagmaking { get; set; }
+
+ [JsonProperty("fluorometer", Required = Required.Always)]
+ public Fluorometer[] Fluorometer { get; set; }
+
+ [JsonProperty("fulsome", Required = Required.Always)]
+ public long?[] Fulsome { get; set; }
+
+ [JsonProperty("fuzzy", Required = Required.Always)]
+ public Fuzzy[] Fuzzy { get; set; }
+
+ [JsonProperty("gardenwards", Required = Required.Always)]
+ public Gardenward[] Gardenwards { get; set; }
+
+ [JsonProperty("generalissimo", Required = Required.Always)]
+ public Generalissimo[] Generalissimo { get; set; }
+
+ [JsonProperty("habeas", Required = Required.Always)]
+ public Dictionary?[] Habeas { get; set; }
+
+ [JsonProperty("hemicrystalline", Required = Required.Always)]
+ public Hemicrystalline[] Hemicrystalline { get; set; }
+
+ [JsonProperty("hemocoele", Required = Required.Always)]
+ public HemocoeleElement[] Hemocoele { get; set; }
+
+ [JsonProperty("hoister", Required = Required.Always)]
+ public Hoister[] Hoister { get; set; }
+
+ [JsonProperty("hyperpiesis", Required = Required.Always)]
+ public Hyperpiesi[] Hyperpiesis { get; set; }
+
+ [JsonProperty("hyppish", Required = Required.Always)]
+ public Hyppish[] Hyppish { get; set; }
+
+ [JsonProperty("idealizer", Required = Required.Always)]
+ public Idealizer[] Idealizer { get; set; }
+
+ [JsonProperty("incrustator", Required = Required.Always)]
+ public Incrustator[] Incrustator { get; set; }
+
+ [JsonProperty("intentiveness", Required = Required.Always)]
+ public Intentiveness[] Intentiveness { get; set; }
+
+ [JsonProperty("interacinar", Required = Required.Always)]
+ public Interacinar Interacinar { get; set; }
+
+ [JsonProperty("intercorrelation", Required = Required.Always)]
+ public long[]?[] Intercorrelation { get; set; }
+
+ [JsonProperty("jacutinga", Required = Required.Always)]
+ public Jacutinga[] Jacutinga { get; set; }
+ }
+
+ public partial class CerographClass
+ {
+ [JsonProperty("apotropaion", Required = Required.AllowNull)]
+ public object Apotropaion { get; set; }
+
+ [JsonProperty("casuary", Required = Required.AllowNull)]
+ public object Casuary { get; set; }
+
+ [JsonProperty("creaker", Required = Required.AllowNull)]
+ public object Creaker { get; set; }
+
+ [JsonProperty("disqualification", Required = Required.AllowNull)]
+ public object Disqualification { get; set; }
+
+ [JsonProperty("imperatorious", Required = Required.AllowNull)]
+ public object Imperatorious { get; set; }
+
+ [JsonProperty("impermeabilize", Required = Required.AllowNull)]
+ public object Impermeabilize { get; set; }
+
+ [JsonProperty("metastoma", Required = Required.AllowNull)]
+ public object Metastoma { get; set; }
+
+ [JsonProperty("noctidiurnal", Required = Required.AllowNull)]
+ public object Noctidiurnal { get; set; }
+
+ [JsonProperty("nonreserve", Required = Required.AllowNull)]
+ public object Nonreserve { get; set; }
+
+ [JsonProperty("ophthalmotonometry", Required = Required.AllowNull)]
+ public object Ophthalmotonometry { get; set; }
+
+ [JsonProperty("pailful", Required = Required.AllowNull)]
+ public object Pailful { get; set; }
+
+ [JsonProperty("pigfish", Required = Required.AllowNull)]
+ public object Pigfish { get; set; }
+
+ [JsonProperty("pongee", Required = Required.AllowNull)]
+ public object Pongee { get; set; }
+
+ [JsonProperty("prosodical", Required = Required.AllowNull)]
+ public object Prosodical { get; set; }
+
+ [JsonProperty("scrofuloderm", Required = Required.AllowNull)]
+ public object Scrofuloderm { get; set; }
+
+ [JsonProperty("storekeeping", Required = Required.AllowNull)]
+ public object Storekeeping { get; set; }
+
+ [JsonProperty("therologist", Required = Required.AllowNull)]
+ public object Therologist { get; set; }
+
+ [JsonProperty("Tolowa", Required = Required.AllowNull)]
+ public object Tolowa { get; set; }
+
+ [JsonProperty("tradeful", Required = Required.AllowNull)]
+ public object Tradeful { get; set; }
+
+ [JsonProperty("unriveting", Required = Required.AllowNull)]
+ public object Unriveting { get; set; }
+ }
+
+ public partial class ChemotherapeuticClass
+ {
+ [JsonProperty("angioneurotic")]
+ public object? Angioneurotic { get; set; }
+
+ [JsonProperty("availment")]
+ public object? Availment { get; set; }
+
+ [JsonProperty("bladelet")]
+ public object? Bladelet { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("caulis")]
+ public object? Caulis { get; set; }
+
+ [JsonProperty("chalcus")]
+ public object? Chalcus { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("enteradenological")]
+ public object? Enteradenological { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("imporosity")]
+ public object? Imporosity { get; set; }
+
+ [JsonProperty("insistently")]
+ public object? Insistently { get; set; }
+
+ [JsonProperty("intraparietal")]
+ public object? Intraparietal { get; set; }
+
+ [JsonProperty("ivied")]
+ public object? Ivied { get; set; }
+
+ [JsonProperty("Maureen")]
+ public object? Maureen { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("nostochine")]
+ public object? Nostochine { get; set; }
+
+ [JsonProperty("nutcracker")]
+ public object? Nutcracker { get; set; }
+
+ [JsonProperty("ofttimes")]
+ public object? Ofttimes { get; set; }
+
+ [JsonProperty("phenocryst")]
+ public object? Phenocryst { get; set; }
+
+ [JsonProperty("precoincident")]
+ public object? Precoincident { get; set; }
+
+ [JsonProperty("ramiferous")]
+ public object? Ramiferous { get; set; }
+
+ [JsonProperty("stagmometer")]
+ public object? Stagmometer { get; set; }
+
+ [JsonProperty("tetherball")]
+ public object? Tetherball { get; set; }
+
+ [JsonProperty("unshy")]
+ public object? Unshy { get; set; }
+ }
+
+ public partial class CimeliaClass
+ {
+ [JsonProperty("catharticalness", Required = Required.Always)]
+ public double Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", Required = Required.Always)]
+ public long Chirotherium { get; set; }
+
+ [JsonProperty("disdiapason", Required = Required.Always)]
+ public string Disdiapason { get; set; }
+
+ [JsonProperty("homocerc", Required = Required.Always)]
+ public bool Homocerc { get; set; }
+
+ [JsonProperty("nonbookish", Required = Required.AllowNull)]
+ public object Nonbookish { get; set; }
+ }
+
+ public partial class CoadjustClass
+ {
+ [JsonProperty("amidosulphonal")]
+ public object? Amidosulphonal { get; set; }
+
+ [JsonProperty("Benny")]
+ public object? Benny { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("ensnare")]
+ public object? Ensnare { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("hybridizer")]
+ public object? Hybridizer { get; set; }
+
+ [JsonProperty("leastwise")]
+ public object? Leastwise { get; set; }
+
+ [JsonProperty("lof")]
+ public object? Lof { get; set; }
+
+ [JsonProperty("monkhood")]
+ public object? Monkhood { get; set; }
+
+ [JsonProperty("Netherlandish")]
+ public object? Netherlandish { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("peonism")]
+ public object? Peonism { get; set; }
+
+ [JsonProperty("Phonelescope")]
+ public object? Phonelescope { get; set; }
+
+ [JsonProperty("porphyrogeniture")]
+ public object? Porphyrogeniture { get; set; }
+
+ [JsonProperty("preindemnify")]
+ public object? Preindemnify { get; set; }
+
+ [JsonProperty("rosal")]
+ public object? Rosal { get; set; }
+
+ [JsonProperty("scalenous")]
+ public object? Scalenous { get; set; }
+
+ [JsonProperty("scopine")]
+ public object? Scopine { get; set; }
+
+ [JsonProperty("Sedaceae")]
+ public object? Sedaceae { get; set; }
+
+ [JsonProperty("suberinize")]
+ public object? Suberinize { get; set; }
+
+ [JsonProperty("symbiot")]
+ public object? Symbiot { get; set; }
+
+ [JsonProperty("tablefellow")]
+ public object? Tablefellow { get; set; }
+
+ [JsonProperty("unchargeable")]
+ public object? Unchargeable { get; set; }
+ }
+
+ public partial class CredulityClass
+ {
+ [JsonProperty("ammonolytic", Required = Required.AllowNull)]
+ public object Ammonolytic { get; set; }
+
+ [JsonProperty("bushmaster", Required = Required.AllowNull)]
+ public object Bushmaster { get; set; }
+
+ [JsonProperty("considering", Required = Required.AllowNull)]
+ public object Considering { get; set; }
+
+ [JsonProperty("consuetudinary", Required = Required.AllowNull)]
+ public object Consuetudinary { get; set; }
+
+ [JsonProperty("embarras", Required = Required.AllowNull)]
+ public object Embarras { get; set; }
+
+ [JsonProperty("fineness", Required = Required.AllowNull)]
+ public object Fineness { get; set; }
+
+ [JsonProperty("flaithship", Required = Required.AllowNull)]
+ public object Flaithship { get; set; }
+
+ [JsonProperty("Flavia", Required = Required.AllowNull)]
+ public object Flavia { get; set; }
+
+ [JsonProperty("gruffly", Required = Required.AllowNull)]
+ public object Gruffly { get; set; }
+
+ [JsonProperty("Hedychium", Required = Required.AllowNull)]
+ public object Hedychium { get; set; }
+
+ [JsonProperty("leadwort", Required = Required.AllowNull)]
+ public object Leadwort { get; set; }
+
+ [JsonProperty("overseriously", Required = Required.AllowNull)]
+ public object Overseriously { get; set; }
+
+ [JsonProperty("parabola", Required = Required.AllowNull)]
+ public object Parabola { get; set; }
+
+ [JsonProperty("pectinatodenticulate", Required = Required.AllowNull)]
+ public object Pectinatodenticulate { get; set; }
+
+ [JsonProperty("Popean", Required = Required.AllowNull)]
+ public object Popean { get; set; }
+
+ [JsonProperty("pornocrat", Required = Required.AllowNull)]
+ public object Pornocrat { get; set; }
+
+ [JsonProperty("quadrisect", Required = Required.AllowNull)]
+ public object Quadrisect { get; set; }
+
+ [JsonProperty("seriality", Required = Required.AllowNull)]
+ public object Seriality { get; set; }
+
+ [JsonProperty("vamphorn", Required = Required.AllowNull)]
+ public object Vamphorn { get; set; }
+
+ [JsonProperty("wharp", Required = Required.AllowNull)]
+ public object Wharp { get; set; }
+ }
+
+ public partial class DeruralizeClass
+ {
+ [JsonProperty("bockerel", Required = Required.AllowNull)]
+ public object Bockerel { get; set; }
+
+ [JsonProperty("boulder", Required = Required.AllowNull)]
+ public object Boulder { get; set; }
+
+ [JsonProperty("churrus", Required = Required.AllowNull)]
+ public object Churrus { get; set; }
+
+ [JsonProperty("counterdigged", Required = Required.AllowNull)]
+ public object Counterdigged { get; set; }
+
+ [JsonProperty("dialogite", Required = Required.AllowNull)]
+ public object Dialogite { get; set; }
+
+ [JsonProperty("digenic", Required = Required.AllowNull)]
+ public object Digenic { get; set; }
+
+ [JsonProperty("dunbird", Required = Required.AllowNull)]
+ public object Dunbird { get; set; }
+
+ [JsonProperty("ergatogyne", Required = Required.AllowNull)]
+ public object Ergatogyne { get; set; }
+
+ [JsonProperty("fiendful", Required = Required.AllowNull)]
+ public object Fiendful { get; set; }
+
+ [JsonProperty("jackrod", Required = Required.AllowNull)]
+ public object Jackrod { get; set; }
+
+ [JsonProperty("Jehovistic", Required = Required.AllowNull)]
+ public object Jehovistic { get; set; }
+
+ [JsonProperty("Paninean", Required = Required.AllowNull)]
+ public object Paninean { get; set; }
+
+ [JsonProperty("panther", Required = Required.AllowNull)]
+ public object Panther { get; set; }
+
+ [JsonProperty("placentigerous", Required = Required.AllowNull)]
+ public object Placentigerous { get; set; }
+
+ [JsonProperty("Romney", Required = Required.AllowNull)]
+ public object Romney { get; set; }
+
+ [JsonProperty("sparm", Required = Required.AllowNull)]
+ public object Sparm { get; set; }
+
+ [JsonProperty("tocsin", Required = Required.AllowNull)]
+ public object Tocsin { get; set; }
+
+ [JsonProperty("unnicked", Required = Required.AllowNull)]
+ public object Unnicked { get; set; }
+
+ [JsonProperty("unstavable", Required = Required.AllowNull)]
+ public object Unstavable { get; set; }
+
+ [JsonProperty("windfirm", Required = Required.AllowNull)]
+ public object Windfirm { get; set; }
+ }
+
+ public partial class DiaereseClass
+ {
+ [JsonProperty("Amoreuxia", Required = Required.AllowNull)]
+ public object Amoreuxia { get; set; }
+
+ [JsonProperty("ani", Required = Required.AllowNull)]
+ public object Ani { get; set; }
+
+ [JsonProperty("bernicle", Required = Required.AllowNull)]
+ public object Bernicle { get; set; }
+
+ [JsonProperty("blackwasher", Required = Required.AllowNull)]
+ public object Blackwasher { get; set; }
+
+ [JsonProperty("blowhard", Required = Required.AllowNull)]
+ public object Blowhard { get; set; }
+
+ [JsonProperty("broma", Required = Required.AllowNull)]
+ public object Broma { get; set; }
+
+ [JsonProperty("closecross", Required = Required.AllowNull)]
+ public object Closecross { get; set; }
+
+ [JsonProperty("congregationalism", Required = Required.AllowNull)]
+ public object Congregationalism { get; set; }
+
+ [JsonProperty("grayly", Required = Required.AllowNull)]
+ public object Grayly { get; set; }
+
+ [JsonProperty("historically", Required = Required.AllowNull)]
+ public object Historically { get; set; }
+
+ [JsonProperty("hoast", Required = Required.AllowNull)]
+ public object Hoast { get; set; }
+
+ [JsonProperty("irretentive", Required = Required.AllowNull)]
+ public object Irretentive { get; set; }
+
+ [JsonProperty("parcener", Required = Required.AllowNull)]
+ public object Parcener { get; set; }
+
+ [JsonProperty("pedder", Required = Required.AllowNull)]
+ public object Pedder { get; set; }
+
+ [JsonProperty("pseudoanatomic", Required = Required.AllowNull)]
+ public object Pseudoanatomic { get; set; }
+
+ [JsonProperty("rhizocarpian", Required = Required.AllowNull)]
+ public object Rhizocarpian { get; set; }
+
+ [JsonProperty("samel", Required = Required.AllowNull)]
+ public object Samel { get; set; }
+
+ [JsonProperty("silker", Required = Required.AllowNull)]
+ public object Silker { get; set; }
+
+ [JsonProperty("subdentated", Required = Required.AllowNull)]
+ public object Subdentated { get; set; }
+
+ [JsonProperty("subobscure", Required = Required.AllowNull)]
+ public object Subobscure { get; set; }
+ }
+
+ public partial class Encrust
+ {
+ [JsonProperty("comradely", Required = Required.AllowNull)]
+ public object Comradely { get; set; }
+
+ [JsonProperty("diacanthous", Required = Required.AllowNull)]
+ public object Diacanthous { get; set; }
+
+ [JsonProperty("feminineness", Required = Required.AllowNull)]
+ public object Feminineness { get; set; }
+
+ [JsonProperty("gossamered", Required = Required.AllowNull)]
+ public object Gossamered { get; set; }
+
+ [JsonProperty("Hibernia", Required = Required.AllowNull)]
+ public object Hibernia { get; set; }
+
+ [JsonProperty("Hibiscus", Required = Required.AllowNull)]
+ public object Hibiscus { get; set; }
+
+ [JsonProperty("Lepidosauria", Required = Required.AllowNull)]
+ public object Lepidosauria { get; set; }
+
+ [JsonProperty("lollingly", Required = Required.AllowNull)]
+ public object Lollingly { get; set; }
+
+ [JsonProperty("manager", Required = Required.AllowNull)]
+ public object Manager { get; set; }
+
+ [JsonProperty("mechanic", Required = Required.AllowNull)]
+ public object Mechanic { get; set; }
+
+ [JsonProperty("overminuteness", Required = Required.AllowNull)]
+ public object Overminuteness { get; set; }
+
+ [JsonProperty("papelonne", Required = Required.AllowNull)]
+ public object Papelonne { get; set; }
+
+ [JsonProperty("plebification", Required = Required.AllowNull)]
+ public object Plebification { get; set; }
+
+ [JsonProperty("pugmiller", Required = Required.AllowNull)]
+ public object Pugmiller { get; set; }
+
+ [JsonProperty("recoveror", Required = Required.AllowNull)]
+ public object Recoveror { get; set; }
+
+ [JsonProperty("spermatoblastic", Required = Required.AllowNull)]
+ public object Spermatoblastic { get; set; }
+
+ [JsonProperty("Syllidae", Required = Required.AllowNull)]
+ public object Syllidae { get; set; }
+
+ [JsonProperty("ungyved", Required = Required.AllowNull)]
+ public object Ungyved { get; set; }
+
+ [JsonProperty("whirlabout", Required = Required.AllowNull)]
+ public object Whirlabout { get; set; }
+
+ [JsonProperty("woodenware", Required = Required.AllowNull)]
+ public object Woodenware { get; set; }
+ }
+
+ public partial class FagginglyClass
+ {
+ [JsonProperty("abranchian", Required = Required.AllowNull)]
+ public object Abranchian { get; set; }
+
+ [JsonProperty("aculeiform", Required = Required.AllowNull)]
+ public object Aculeiform { get; set; }
+
+ [JsonProperty("adiaphoristic", Required = Required.AllowNull)]
+ public object Adiaphoristic { get; set; }
+
+ [JsonProperty("adoptionism", Required = Required.AllowNull)]
+ public object Adoptionism { get; set; }
+
+ [JsonProperty("Anglic", Required = Required.AllowNull)]
+ public object Anglic { get; set; }
+
+ [JsonProperty("antrotomy", Required = Required.AllowNull)]
+ public object Antrotomy { get; set; }
+
+ [JsonProperty("coerciveness", Required = Required.AllowNull)]
+ public object Coerciveness { get; set; }
+
+ [JsonProperty("decorist", Required = Required.AllowNull)]
+ public object Decorist { get; set; }
+
+ [JsonProperty("duckhood", Required = Required.AllowNull)]
+ public object Duckhood { get; set; }
+
+ [JsonProperty("Heteromeri", Required = Required.AllowNull)]
+ public object Heteromeri { get; set; }
+
+ [JsonProperty("hypochnose", Required = Required.AllowNull)]
+ public object Hypochnose { get; set; }
+
+ [JsonProperty("lochage", Required = Required.AllowNull)]
+ public object Lochage { get; set; }
+
+ [JsonProperty("melee", Required = Required.AllowNull)]
+ public object Melee { get; set; }
+
+ [JsonProperty("nonconformitant", Required = Required.AllowNull)]
+ public object Nonconformitant { get; set; }
+
+ [JsonProperty("Poinsettia", Required = Required.AllowNull)]
+ public object Poinsettia { get; set; }
+
+ [JsonProperty("putatively", Required = Required.AllowNull)]
+ public object Putatively { get; set; }
+
+ [JsonProperty("semivolatile", Required = Required.AllowNull)]
+ public object Semivolatile { get; set; }
+
+ [JsonProperty("soleas", Required = Required.AllowNull)]
+ public object Soleas { get; set; }
+
+ [JsonProperty("unfastenable", Required = Required.AllowNull)]
+ public object Unfastenable { get; set; }
+
+ [JsonProperty("unmillinered", Required = Required.AllowNull)]
+ public object Unmillinered { get; set; }
+ }
+
+ public partial class FenkClass
+ {
+ [JsonProperty("apoise", Required = Required.AllowNull)]
+ public object Apoise { get; set; }
+
+ [JsonProperty("astronomize", Required = Required.AllowNull)]
+ public object Astronomize { get; set; }
+
+ [JsonProperty("cockhorse", Required = Required.AllowNull)]
+ public object Cockhorse { get; set; }
+
+ [JsonProperty("copular", Required = Required.AllowNull)]
+ public object Copular { get; set; }
+
+ [JsonProperty("Dagomba", Required = Required.AllowNull)]
+ public object Dagomba { get; set; }
+
+ [JsonProperty("draffy", Required = Required.AllowNull)]
+ public object Draffy { get; set; }
+
+ [JsonProperty("foreigner", Required = Required.AllowNull)]
+ public object Foreigner { get; set; }
+
+ [JsonProperty("Guyandot", Required = Required.AllowNull)]
+ public object Guyandot { get; set; }
+
+ [JsonProperty("neurogliosis", Required = Required.AllowNull)]
+ public object Neurogliosis { get; set; }
+
+ [JsonProperty("osmious", Required = Required.AllowNull)]
+ public object Osmious { get; set; }
+
+ [JsonProperty("palpitate", Required = Required.AllowNull)]
+ public object Palpitate { get; set; }
+
+ [JsonProperty("rebukeable", Required = Required.AllowNull)]
+ public object Rebukeable { get; set; }
+
+ [JsonProperty("Reinwardtia", Required = Required.AllowNull)]
+ public object Reinwardtia { get; set; }
+
+ [JsonProperty("reservatory", Required = Required.AllowNull)]
+ public object Reservatory { get; set; }
+
+ [JsonProperty("scalt", Required = Required.AllowNull)]
+ public object Scalt { get; set; }
+
+ [JsonProperty("scripturalize", Required = Required.AllowNull)]
+ public object Scripturalize { get; set; }
+
+ [JsonProperty("tintometer", Required = Required.AllowNull)]
+ public object Tintometer { get; set; }
+
+ [JsonProperty("Tritoness", Required = Required.AllowNull)]
+ public object Tritoness { get; set; }
+
+ [JsonProperty("undergrade", Required = Required.AllowNull)]
+ public object Undergrade { get; set; }
+
+ [JsonProperty("undermountain", Required = Required.AllowNull)]
+ public object Undermountain { get; set; }
+ }
+
+ public partial class FlagmakingClass
+ {
+ [JsonProperty("albarco", Required = Required.AllowNull)]
+ public object Albarco { get; set; }
+
+ [JsonProperty("Bunodonta", Required = Required.AllowNull)]
+ public object Bunodonta { get; set; }
+
+ [JsonProperty("hornify", Required = Required.AllowNull)]
+ public object Hornify { get; set; }
+
+ [JsonProperty("Hydrocorisae", Required = Required.AllowNull)]
+ public object Hydrocorisae { get; set; }
+
+ [JsonProperty("hypoglossus", Required = Required.AllowNull)]
+ public object Hypoglossus { get; set; }
+
+ [JsonProperty("inexpiably", Required = Required.AllowNull)]
+ public object Inexpiably { get; set; }
+
+ [JsonProperty("ingratitude", Required = Required.AllowNull)]
+ public object Ingratitude { get; set; }
+
+ [JsonProperty("ladyfly", Required = Required.AllowNull)]
+ public object Ladyfly { get; set; }
+
+ [JsonProperty("medicament", Required = Required.AllowNull)]
+ public object Medicament { get; set; }
+
+ [JsonProperty("monogrammatic", Required = Required.AllowNull)]
+ public object Monogrammatic { get; set; }
+
+ [JsonProperty("nobbut", Required = Required.AllowNull)]
+ public object Nobbut { get; set; }
+
+ [JsonProperty("Notacanthidae", Required = Required.AllowNull)]
+ public object Notacanthidae { get; set; }
+
+ [JsonProperty("polyplacophore", Required = Required.AllowNull)]
+ public object Polyplacophore { get; set; }
+
+ [JsonProperty("proexercise", Required = Required.AllowNull)]
+ public object Proexercise { get; set; }
+
+ [JsonProperty("protoplast", Required = Required.AllowNull)]
+ public object Protoplast { get; set; }
+
+ [JsonProperty("puzzling", Required = Required.AllowNull)]
+ public object Puzzling { get; set; }
+
+ [JsonProperty("splanchnoskeleton", Required = Required.AllowNull)]
+ public object Splanchnoskeleton { get; set; }
+
+ [JsonProperty("unloveliness", Required = Required.AllowNull)]
+ public object Unloveliness { get; set; }
+
+ [JsonProperty("unquarantined", Required = Required.AllowNull)]
+ public object Unquarantined { get; set; }
+
+ [JsonProperty("unrenounceable", Required = Required.AllowNull)]
+ public object Unrenounceable { get; set; }
+ }
+
+ public partial class HemocoeleClass
+ {
+ [JsonProperty("acrogamy")]
+ public object? Acrogamy { get; set; }
+
+ [JsonProperty("amelification")]
+ public object? Amelification { get; set; }
+
+ [JsonProperty("autobiographic")]
+ public object? Autobiographic { get; set; }
+
+ [JsonProperty("berat")]
+ public object? Berat { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("disproportionably")]
+ public object? Disproportionably { get; set; }
+
+ [JsonProperty("erythrite")]
+ public object? Erythrite { get; set; }
+
+ [JsonProperty("graphic")]
+ public object? Graphic { get; set; }
+
+ [JsonProperty("hepatological")]
+ public object? Hepatological { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("incommensurably")]
+ public object? Incommensurably { get; set; }
+
+ [JsonProperty("misaffirm")]
+ public object? Misaffirm { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("pocketbook")]
+ public object? Pocketbook { get; set; }
+
+ [JsonProperty("sclerometric")]
+ public object? Sclerometric { get; set; }
+
+ [JsonProperty("stambouline")]
+ public object? Stambouline { get; set; }
+
+ [JsonProperty("stickpin")]
+ public object? Stickpin { get; set; }
+
+ [JsonProperty("tubulure")]
+ public object? Tubulure { get; set; }
+
+ [JsonProperty("undelated")]
+ public object? Undelated { get; set; }
+
+ [JsonProperty("unsalt")]
+ public object? Unsalt { get; set; }
+
+ [JsonProperty("untutelar")]
+ public object? Untutelar { get; set; }
+
+ [JsonProperty("vagrant")]
+ public object? Vagrant { get; set; }
+
+ [JsonProperty("Walt")]
+ public object? Walt { get; set; }
+ }
+
+ public partial class Interacinar
+ {
+ [JsonProperty("assapan", Required = Required.Always)]
+ public double Assapan { get; set; }
+
+ [JsonProperty("benefactorship", Required = Required.Always)]
+ public bool Benefactorship { get; set; }
+
+ [JsonProperty("triseriatim", Required = Required.Always)]
+ public string Triseriatim { get; set; }
+
+ [JsonProperty("tubbing", Required = Required.Always)]
+ public long Tubbing { get; set; }
+
+ [JsonProperty("untrimmed", Required = Required.AllowNull)]
+ public object Untrimmed { get; set; }
+ }
+
+ public partial struct CerographElement
+ {
+ public CerographClass? CerographClass;
+ public string? String;
+
+ public static implicit operator CerographElement(CerographClass CerographClass) => new CerographElement { CerographClass = CerographClass };
+ public static implicit operator CerographElement(string String) => new CerographElement { String = String };
+ public bool IsNull => CerographClass == null && String == null;
+ }
+
+ public partial struct ChemotherapeuticElement
+ {
+ public ChemotherapeuticClass? ChemotherapeuticClass;
+ public long? Integer;
+
+ public static implicit operator ChemotherapeuticElement(ChemotherapeuticClass ChemotherapeuticClass) => new ChemotherapeuticElement { ChemotherapeuticClass = ChemotherapeuticClass };
+ public static implicit operator ChemotherapeuticElement(long Integer) => new ChemotherapeuticElement { Integer = Integer };
+ }
+
+ public partial struct CimeliaElement
+ {
+ public CimeliaClass? CimeliaClass;
+ public long[]? IntegerArray;
+
+ public static implicit operator CimeliaElement(CimeliaClass CimeliaClass) => new CimeliaElement { CimeliaClass = CimeliaClass };
+ public static implicit operator CimeliaElement(long[] IntegerArray) => new CimeliaElement { IntegerArray = IntegerArray };
+ public bool IsNull => IntegerArray == null && CimeliaClass == null;
+ }
+
+ public partial struct Clinodome
+ {
+ public double? Double;
+ public string? String;
+
+ public static implicit operator Clinodome(double Double) => new Clinodome { Double = Double };
+ public static implicit operator Clinodome(string String) => new Clinodome { String = String };
+ }
+
+ public partial struct CoadjustElement
+ {
+ public CoadjustClass? CoadjustClass;
+ public double? Double;
+
+ public static implicit operator CoadjustElement(CoadjustClass CoadjustClass) => new CoadjustElement { CoadjustClass = CoadjustClass };
+ public static implicit operator CoadjustElement(double Double) => new CoadjustElement { Double = Double };
+ }
+
+ public partial struct Consilience
+ {
+ public double? Double;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Consilience(double Double) => new Consilience { Double = Double };
+ public static implicit operator Consilience(Dictionary IntegerMap) => new Consilience { IntegerMap = IntegerMap };
+ }
+
+ public partial struct Constructor
+ {
+ public bool? Bool;
+ public Dictionary? UnionMap;
+
+ public static implicit operator Constructor(bool Bool) => new Constructor { Bool = Bool };
+ public static implicit operator Constructor(Dictionary UnionMap) => new Constructor { UnionMap = UnionMap };
+ }
+
+ public partial struct Continuative
+ {
+ public Dictionary? IntegerMap;
+ public string? String;
+
+ public static implicit operator Continuative(Dictionary IntegerMap) => new Continuative { IntegerMap = IntegerMap };
+ public static implicit operator Continuative(string String) => new Continuative { String = String };
+ }
+
+ public partial struct CredulityElement
+ {
+ public CredulityClass? CredulityClass;
+ public long? Integer;
+ public string? String;
+
+ public static implicit operator CredulityElement(CredulityClass CredulityClass) => new CredulityElement { CredulityClass = CredulityClass };
+ public static implicit operator CredulityElement(long Integer) => new CredulityElement { Integer = Integer };
+ public static implicit operator CredulityElement(string String) => new CredulityElement { String = String };
+ }
+
+ public partial struct Creviced
+ {
+ public bool? Bool;
+ public Dictionary? IntegerMap;
+ public string? String;
+
+ public static implicit operator Creviced(bool Bool) => new Creviced { Bool = Bool };
+ public static implicit operator Creviced(Dictionary IntegerMap) => new Creviced { IntegerMap = IntegerMap };
+ public static implicit operator Creviced(string String) => new Creviced { String = String };
+ }
+
+ public partial struct DeruralizeElement
+ {
+ public bool? Bool;
+ public DeruralizeClass? DeruralizeClass;
+ public object[]? NullArray;
+
+ public static implicit operator DeruralizeElement(bool Bool) => new DeruralizeElement { Bool = Bool };
+ public static implicit operator DeruralizeElement(DeruralizeClass DeruralizeClass) => new DeruralizeElement { DeruralizeClass = DeruralizeClass };
+ public static implicit operator DeruralizeElement(object[] NullArray) => new DeruralizeElement { NullArray = NullArray };
+ }
+
+ public partial struct DiaereseElement
+ {
+ public bool? Bool;
+ public DiaereseClass? DiaereseClass;
+ public long[]? IntegerArray;
+
+ public static implicit operator DiaereseElement(bool Bool) => new DiaereseElement { Bool = Bool };
+ public static implicit operator DiaereseElement(DiaereseClass DiaereseClass) => new DiaereseElement { DiaereseClass = DiaereseClass };
+ public static implicit operator DiaereseElement(long[] IntegerArray) => new DiaereseElement { IntegerArray = IntegerArray };
+ }
+
+ public partial struct Downstroke
+ {
+ public bool? Bool;
+ public object[]? NullArray;
+ public string? String;
+
+ public static implicit operator Downstroke(bool Bool) => new Downstroke { Bool = Bool };
+ public static implicit operator Downstroke(object[] NullArray) => new Downstroke { NullArray = NullArray };
+ public static implicit operator Downstroke(string String) => new Downstroke { String = String };
+ }
+
+ public partial struct Eleutheromania
+ {
+ public double? Double;
+ public Dictionary? IntegerMap;
+ public string? String;
+
+ public static implicit operator Eleutheromania(double Double) => new Eleutheromania { Double = Double };
+ public static implicit operator Eleutheromania(Dictionary IntegerMap) => new Eleutheromania { IntegerMap = IntegerMap };
+ public static implicit operator Eleutheromania(string String) => new Eleutheromania { String = String };
+ }
+
+ public partial struct Entomoid
+ {
+ public CimeliaClass? CimeliaClass;
+ public long? Integer;
+
+ public static implicit operator Entomoid(CimeliaClass CimeliaClass) => new Entomoid { CimeliaClass = CimeliaClass };
+ public static implicit operator Entomoid(long Integer) => new Entomoid { Integer = Integer };
+ }
+
+ public partial struct Epipaleolithic
+ {
+ public double? Double;
+ public long[]? IntegerArray;
+
+ public static implicit operator Epipaleolithic(double Double) => new Epipaleolithic { Double = Double };
+ public static implicit operator Epipaleolithic(long[] IntegerArray) => new Epipaleolithic { IntegerArray = IntegerArray };
+ }
+
+ public partial struct Expropriable
+ {
+ public CimeliaClass? CimeliaClass;
+ public double? Double;
+ public object[]? NullArray;
+
+ public static implicit operator Expropriable(CimeliaClass CimeliaClass) => new Expropriable { CimeliaClass = CimeliaClass };
+ public static implicit operator Expropriable(double Double) => new Expropriable { Double = Double };
+ public static implicit operator Expropriable(object[] NullArray) => new Expropriable { NullArray = NullArray };
+ }
+
+ public partial struct FagginglyElement
+ {
+ public double? Double;
+ public FagginglyClass? FagginglyClass;
+
+ public static implicit operator FagginglyElement(double Double) => new FagginglyElement { Double = Double };
+ public static implicit operator FagginglyElement(FagginglyClass FagginglyClass) => new FagginglyElement { FagginglyClass = FagginglyClass };
+ }
+
+ public partial struct FenkElement
+ {
+ public FenkClass? FenkClass;
+ public string? String;
+
+ public static implicit operator FenkElement(FenkClass FenkClass) => new FenkElement { FenkClass = FenkClass };
+ public static implicit operator FenkElement(string String) => new FenkElement { String = String };
+ }
+
+ public partial struct FlagmakingElement
+ {
+ public bool? Bool;
+ public double? Double;
+ public FlagmakingClass? FlagmakingClass;
+
+ public static implicit operator FlagmakingElement(bool Bool) => new FlagmakingElement { Bool = Bool };
+ public static implicit operator FlagmakingElement(double Double) => new FlagmakingElement { Double = Double };
+ public static implicit operator FlagmakingElement(FlagmakingClass FlagmakingClass) => new FlagmakingElement { FlagmakingClass = FlagmakingClass };
+ }
+
+ public partial struct Fluorometer
+ {
+ public long? Integer;
+ public string? String;
+
+ public static implicit operator Fluorometer(long Integer) => new Fluorometer { Integer = Integer };
+ public static implicit operator Fluorometer(string String) => new Fluorometer { String = String };
+ public bool IsNull => Integer == null && String == null;
+ }
+
+ public partial struct Fuzzy
+ {
+ public long? Integer;
+ public Dictionary? UnionMap;
+
+ public static implicit operator Fuzzy(long Integer) => new Fuzzy { Integer = Integer };
+ public static implicit operator Fuzzy(Dictionary UnionMap) => new Fuzzy { UnionMap = UnionMap };
+ }
+
+ public partial struct Gardenward
+ {
+ public bool? Bool;
+ public long[]? IntegerArray;
+ public string? String;
+
+ public static implicit operator Gardenward(bool Bool) => new Gardenward { Bool = Bool };
+ public static implicit operator Gardenward(long[] IntegerArray) => new Gardenward { IntegerArray = IntegerArray };
+ public static implicit operator Gardenward(string String) => new Gardenward { String = String };
+ }
+
+ public partial struct Generalissimo
+ {
+ public bool? Bool;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Generalissimo(bool Bool) => new Generalissimo { Bool = Bool };
+ public static implicit operator Generalissimo(Dictionary IntegerMap) => new Generalissimo { IntegerMap = IntegerMap };
+ public bool IsNull => Bool == null && IntegerMap == null;
+ }
+
+ public partial struct Hemicrystalline
+ {
+ public CimeliaClass? CimeliaClass;
+ public string? String;
+
+ public static implicit operator Hemicrystalline(CimeliaClass CimeliaClass) => new Hemicrystalline { CimeliaClass = CimeliaClass };
+ public static implicit operator Hemicrystalline(string String) => new Hemicrystalline { String = String };
+ }
+
+ public partial struct HemocoeleElement
+ {
+ public HemocoeleClass? HemocoeleClass;
+ public long[]? IntegerArray;
+
+ public static implicit operator HemocoeleElement(HemocoeleClass HemocoeleClass) => new HemocoeleElement { HemocoeleClass = HemocoeleClass };
+ public static implicit operator HemocoeleElement(long[] IntegerArray) => new HemocoeleElement { IntegerArray = IntegerArray };
+ }
+
+ public partial struct Hoister
+ {
+ public CimeliaClass? CimeliaClass;
+ public string? String;
+
+ public static implicit operator Hoister(CimeliaClass CimeliaClass) => new Hoister { CimeliaClass = CimeliaClass };
+ public static implicit operator Hoister(string String) => new Hoister { String = String };
+ public bool IsNull => CimeliaClass == null && String == null;
+ }
+
+ public partial struct Hyperpiesi
+ {
+ public CimeliaClass? CimeliaClass;
+ public object[]? NullArray;
+
+ public static implicit operator Hyperpiesi(CimeliaClass CimeliaClass) => new Hyperpiesi { CimeliaClass = CimeliaClass };
+ public static implicit operator Hyperpiesi(object[] NullArray) => new Hyperpiesi { NullArray = NullArray };
+ public bool IsNull => NullArray == null && CimeliaClass == null;
+ }
+
+ public partial struct Hyppish
+ {
+ public bool? Bool;
+ public string? String;
+
+ public static implicit operator Hyppish(bool Bool) => new Hyppish { Bool = Bool };
+ public static implicit operator Hyppish(string String) => new Hyppish { String = String };
+ public bool IsNull => Bool == null && String == null;
+ }
+
+ public partial struct Idealizer
+ {
+ public CimeliaClass? CimeliaClass;
+ public long? Integer;
+ public object[]? NullArray;
+
+ public static implicit operator Idealizer(CimeliaClass CimeliaClass) => new Idealizer { CimeliaClass = CimeliaClass };
+ public static implicit operator Idealizer(long Integer) => new Idealizer { Integer = Integer };
+ public static implicit operator Idealizer(object[] NullArray) => new Idealizer { NullArray = NullArray };
+ }
+
+ public partial struct Incrustator
+ {
+ public long? Integer;
+ public long[]? IntegerArray;
+ public string? String;
+
+ public static implicit operator Incrustator(long Integer) => new Incrustator { Integer = Integer };
+ public static implicit operator Incrustator(long[] IntegerArray) => new Incrustator { IntegerArray = IntegerArray };
+ public static implicit operator Incrustator(string String) => new Incrustator { String = String };
+ }
+
+ public partial struct Intentiveness
+ {
+ public CimeliaClass? CimeliaClass;
+ public double? Double;
+ public string? String;
+
+ public static implicit operator Intentiveness(CimeliaClass CimeliaClass) => new Intentiveness { CimeliaClass = CimeliaClass };
+ public static implicit operator Intentiveness(double Double) => new Intentiveness { Double = Double };
+ public static implicit operator Intentiveness(string String) => new Intentiveness { String = String };
+ }
+
+ public partial struct Jacutinga
+ {
+ public long[]? IntegerArray;
+ public Dictionary? UnionMap;
+
+ public static implicit operator Jacutinga(long[] IntegerArray) => new Jacutinga { IntegerArray = IntegerArray };
+ public static implicit operator Jacutinga(Dictionary UnionMap) => new Jacutinga { UnionMap = UnionMap };
+ }
+
+ public partial class TopLevel
+ {
+ public static TopLevel? FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings);
+ }
+
+ public static partial class Serialize
+ {
+ public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
+ }
+
+ internal static partial class Converter
+ {
+ public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
+ {
+ MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
+ DateParseHandling = DateParseHandling.None,
+ Converters =
+ {
+ CerographElementConverter.Singleton,
+ ChemotherapeuticElementConverter.Singleton,
+ CimeliaElementConverter.Singleton,
+ ClinodomeConverter.Singleton,
+ CoadjustElementConverter.Singleton,
+ ConsilienceConverter.Singleton,
+ ConstructorConverter.Singleton,
+ ContinuativeConverter.Singleton,
+ CredulityElementConverter.Singleton,
+ CrevicedConverter.Singleton,
+ DeruralizeElementConverter.Singleton,
+ DiaereseElementConverter.Singleton,
+ DownstrokeConverter.Singleton,
+ EleutheromaniaConverter.Singleton,
+ EntomoidConverter.Singleton,
+ EpipaleolithicConverter.Singleton,
+ ExpropriableConverter.Singleton,
+ FagginglyElementConverter.Singleton,
+ FenkElementConverter.Singleton,
+ FlagmakingElementConverter.Singleton,
+ FluorometerConverter.Singleton,
+ FuzzyConverter.Singleton,
+ GardenwardConverter.Singleton,
+ GeneralissimoConverter.Singleton,
+ HemicrystallineConverter.Singleton,
+ HemocoeleElementConverter.Singleton,
+ HoisterConverter.Singleton,
+ HyperpiesiConverter.Singleton,
+ HyppishConverter.Singleton,
+ IdealizerConverter.Singleton,
+ IncrustatorConverter.Singleton,
+ IntentivenessConverter.Singleton,
+ JacutingaConverter.Singleton,
+ new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
+ },
+ };
+ }
+
+ internal class CerographElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(CerographElement) || t == typeof(CerographElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new CerographElement { };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new CerographElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new CerographElement { CerographClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type CerographElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (CerographElement)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.CerographClass != null)
+ {
+ serializer.Serialize(writer, value.CerographClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type CerographElement");
+ }
+
+ public static readonly CerographElementConverter Singleton = new CerographElementConverter();
+ }
+
+ internal class ChemotherapeuticElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(ChemotherapeuticElement) || t == typeof(ChemotherapeuticElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new ChemotherapeuticElement { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new ChemotherapeuticElement { ChemotherapeuticClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type ChemotherapeuticElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (ChemotherapeuticElement)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.ChemotherapeuticClass != null)
+ {
+ serializer.Serialize(writer, value.ChemotherapeuticClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type ChemotherapeuticElement");
+ }
+
+ public static readonly ChemotherapeuticElementConverter Singleton = new ChemotherapeuticElementConverter();
+ }
+
+ internal class CimeliaElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(CimeliaElement) || t == typeof(CimeliaElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new CimeliaElement { };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new CimeliaElement { CimeliaClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new CimeliaElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type CimeliaElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (CimeliaElement)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type CimeliaElement");
+ }
+
+ public static readonly CimeliaElementConverter Singleton = new CimeliaElementConverter();
+ }
+
+ internal class ClinodomeConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Clinodome) || t == typeof(Clinodome?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Clinodome { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Clinodome { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Clinodome");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Clinodome)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Clinodome");
+ }
+
+ public static readonly ClinodomeConverter Singleton = new ClinodomeConverter();
+ }
+
+ internal class CoadjustElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(CoadjustElement) || t == typeof(CoadjustElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new CoadjustElement { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new CoadjustElement { CoadjustClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type CoadjustElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (CoadjustElement)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.CoadjustClass != null)
+ {
+ serializer.Serialize(writer, value.CoadjustClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type CoadjustElement");
+ }
+
+ public static readonly CoadjustElementConverter Singleton = new CoadjustElementConverter();
+ }
+
+ internal class ConsilienceConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Consilience) || t == typeof(Consilience?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Consilience { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Consilience { IntegerMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Consilience");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Consilience)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Consilience");
+ }
+
+ public static readonly ConsilienceConverter Singleton = new ConsilienceConverter();
+ }
+
+ internal class ConstructorConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Constructor) || t == typeof(Constructor?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Constructor { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Constructor { UnionMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Constructor");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Constructor)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.UnionMap != null)
+ {
+ serializer.Serialize(writer, value.UnionMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Constructor");
+ }
+
+ public static readonly ConstructorConverter Singleton = new ConstructorConverter();
+ }
+
+ internal class ContinuativeConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Continuative) || t == typeof(Continuative?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Continuative { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Continuative { IntegerMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Continuative");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Continuative)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Continuative");
+ }
+
+ public static readonly ContinuativeConverter Singleton = new ContinuativeConverter();
+ }
+
+ internal class CredulityElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(CredulityElement) || t == typeof(CredulityElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new CredulityElement { Integer = integerValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new CredulityElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new CredulityElement { CredulityClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type CredulityElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (CredulityElement)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.CredulityClass != null)
+ {
+ serializer.Serialize(writer, value.CredulityClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type CredulityElement");
+ }
+
+ public static readonly CredulityElementConverter Singleton = new CredulityElementConverter();
+ }
+
+ internal class CrevicedConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Creviced) || t == typeof(Creviced?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Creviced { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Creviced { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Creviced { IntegerMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Creviced");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Creviced)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Creviced");
+ }
+
+ public static readonly CrevicedConverter Singleton = new CrevicedConverter();
+ }
+
+ internal class DeruralizeElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(DeruralizeElement) || t == typeof(DeruralizeElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new DeruralizeElement { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new DeruralizeElement { DeruralizeClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new DeruralizeElement { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type DeruralizeElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (DeruralizeElement)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.DeruralizeClass != null)
+ {
+ serializer.Serialize(writer, value.DeruralizeClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type DeruralizeElement");
+ }
+
+ public static readonly DeruralizeElementConverter Singleton = new DeruralizeElementConverter();
+ }
+
+ internal class DiaereseElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(DiaereseElement) || t == typeof(DiaereseElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new DiaereseElement { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new DiaereseElement { DiaereseClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new DiaereseElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type DiaereseElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (DiaereseElement)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.DiaereseClass != null)
+ {
+ serializer.Serialize(writer, value.DiaereseClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type DiaereseElement");
+ }
+
+ public static readonly DiaereseElementConverter Singleton = new DiaereseElementConverter();
+ }
+
+ internal class DownstrokeConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Downstroke) || t == typeof(Downstroke?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Downstroke { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Downstroke { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Downstroke { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Downstroke");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Downstroke)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Downstroke");
+ }
+
+ public static readonly DownstrokeConverter Singleton = new DownstrokeConverter();
+ }
+
+ internal class EleutheromaniaConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Eleutheromania) || t == typeof(Eleutheromania?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Eleutheromania { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Eleutheromania { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Eleutheromania { IntegerMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Eleutheromania");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Eleutheromania)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Eleutheromania");
+ }
+
+ public static readonly EleutheromaniaConverter Singleton = new EleutheromaniaConverter();
+ }
+
+ internal class EntomoidConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Entomoid) || t == typeof(Entomoid?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Entomoid { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Entomoid { CimeliaClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Entomoid");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Entomoid)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Entomoid");
+ }
+
+ public static readonly EntomoidConverter Singleton = new EntomoidConverter();
+ }
+
+ internal class EpipaleolithicConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Epipaleolithic) || t == typeof(Epipaleolithic?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Epipaleolithic { Double = doubleValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Epipaleolithic { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Epipaleolithic");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Epipaleolithic)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Epipaleolithic");
+ }
+
+ public static readonly EpipaleolithicConverter Singleton = new EpipaleolithicConverter();
+ }
+
+ internal class ExpropriableConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Expropriable) || t == typeof(Expropriable?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Expropriable { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Expropriable { CimeliaClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Expropriable { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Expropriable");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Expropriable)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Expropriable");
+ }
+
+ public static readonly ExpropriableConverter Singleton = new ExpropriableConverter();
+ }
+
+ internal class FagginglyElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(FagginglyElement) || t == typeof(FagginglyElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new FagginglyElement { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new FagginglyElement { FagginglyClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type FagginglyElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (FagginglyElement)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.FagginglyClass != null)
+ {
+ serializer.Serialize(writer, value.FagginglyClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type FagginglyElement");
+ }
+
+ public static readonly FagginglyElementConverter Singleton = new FagginglyElementConverter();
+ }
+
+ internal class FenkElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(FenkElement) || t == typeof(FenkElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new FenkElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new FenkElement { FenkClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type FenkElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (FenkElement)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.FenkClass != null)
+ {
+ serializer.Serialize(writer, value.FenkClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type FenkElement");
+ }
+
+ public static readonly FenkElementConverter Singleton = new FenkElementConverter();
+ }
+
+ internal class FlagmakingElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(FlagmakingElement) || t == typeof(FlagmakingElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new FlagmakingElement { Double = doubleValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new FlagmakingElement { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new FlagmakingElement { FlagmakingClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type FlagmakingElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (FlagmakingElement)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.FlagmakingClass != null)
+ {
+ serializer.Serialize(writer, value.FlagmakingClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type FlagmakingElement");
+ }
+
+ public static readonly FlagmakingElementConverter Singleton = new FlagmakingElementConverter();
+ }
+
+ internal class FluorometerConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Fluorometer) || t == typeof(Fluorometer?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Fluorometer { };
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Fluorometer { Integer = integerValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Fluorometer { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Fluorometer");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Fluorometer)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Fluorometer");
+ }
+
+ public static readonly FluorometerConverter Singleton = new FluorometerConverter();
+ }
+
+ internal class FuzzyConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Fuzzy) || t == typeof(Fuzzy?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Fuzzy { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Fuzzy { UnionMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Fuzzy");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Fuzzy)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.UnionMap != null)
+ {
+ serializer.Serialize(writer, value.UnionMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Fuzzy");
+ }
+
+ public static readonly FuzzyConverter Singleton = new FuzzyConverter();
+ }
+
+ internal class GardenwardConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Gardenward) || t == typeof(Gardenward?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Gardenward { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Gardenward { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Gardenward { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Gardenward");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Gardenward)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Gardenward");
+ }
+
+ public static readonly GardenwardConverter Singleton = new GardenwardConverter();
+ }
+
+ internal class GeneralissimoConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Generalissimo) || t == typeof(Generalissimo?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Generalissimo { };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Generalissimo { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Generalissimo { IntegerMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Generalissimo");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Generalissimo)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Generalissimo");
+ }
+
+ public static readonly GeneralissimoConverter Singleton = new GeneralissimoConverter();
+ }
+
+ internal class HemicrystallineConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Hemicrystalline) || t == typeof(Hemicrystalline?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Hemicrystalline { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Hemicrystalline { CimeliaClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Hemicrystalline");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Hemicrystalline)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Hemicrystalline");
+ }
+
+ public static readonly HemicrystallineConverter Singleton = new HemicrystallineConverter();
+ }
+
+ internal class HemocoeleElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(HemocoeleElement) || t == typeof(HemocoeleElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new HemocoeleElement { HemocoeleClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new HemocoeleElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type HemocoeleElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (HemocoeleElement)untypedValue;
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.HemocoeleClass != null)
+ {
+ serializer.Serialize(writer, value.HemocoeleClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type HemocoeleElement");
+ }
+
+ public static readonly HemocoeleElementConverter Singleton = new HemocoeleElementConverter();
+ }
+
+ internal class HoisterConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Hoister) || t == typeof(Hoister?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Hoister { };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Hoister { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Hoister { CimeliaClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Hoister");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Hoister)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Hoister");
+ }
+
+ public static readonly HoisterConverter Singleton = new HoisterConverter();
+ }
+
+ internal class HyperpiesiConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Hyperpiesi) || t == typeof(Hyperpiesi?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Hyperpiesi { };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Hyperpiesi { CimeliaClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Hyperpiesi { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Hyperpiesi");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Hyperpiesi)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Hyperpiesi");
+ }
+
+ public static readonly HyperpiesiConverter Singleton = new HyperpiesiConverter();
+ }
+
+ internal class HyppishConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Hyppish) || t == typeof(Hyppish?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Hyppish { };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Hyppish { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Hyppish { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Hyppish");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Hyppish)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Hyppish");
+ }
+
+ public static readonly HyppishConverter Singleton = new HyppishConverter();
+ }
+
+ internal class IdealizerConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Idealizer) || t == typeof(Idealizer?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Idealizer { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Idealizer { CimeliaClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Idealizer { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Idealizer");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Idealizer)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Idealizer");
+ }
+
+ public static readonly IdealizerConverter Singleton = new IdealizerConverter();
+ }
+
+ internal class IncrustatorConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Incrustator) || t == typeof(Incrustator?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Incrustator { Integer = integerValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Incrustator { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Incrustator { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Incrustator");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Incrustator)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Incrustator");
+ }
+
+ public static readonly IncrustatorConverter Singleton = new IncrustatorConverter();
+ }
+
+ internal class IntentivenessConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Intentiveness) || t == typeof(Intentiveness?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Intentiveness { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Intentiveness { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Intentiveness { CimeliaClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Intentiveness");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Intentiveness)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.CimeliaClass != null)
+ {
+ serializer.Serialize(writer, value.CimeliaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type Intentiveness");
+ }
+
+ public static readonly IntentivenessConverter Singleton = new IntentivenessConverter();
+ }
+
+ internal class JacutingaConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Jacutinga) || t == typeof(Jacutinga?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Jacutinga { UnionMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Jacutinga { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Jacutinga");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Jacutinga)untypedValue;
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.UnionMap != null)
+ {
+ serializer.Serialize(writer, value.UnionMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Jacutinga");
+ }
+
+ public static readonly JacutingaConverter Singleton = new JacutingaConverter();
+ }
+}
+#pragma warning restore CS8618
+#pragma warning restore CS8601
+#pragma warning restore CS8602
+#pragma warning restore CS8603
+#pragma warning restore CS8604
+#pragma warning restore CS8625
+#pragma warning restore CS8765
diff --git a/head/csharp/test/inputs/json/priority/combinations2.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs b/head/csharp/test/inputs/json/priority/combinations2.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs
new file mode 100644
index 0000000..7e91769
--- /dev/null
+++ b/head/csharp/test/inputs/json/priority/combinations2.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs
@@ -0,0 +1,2668 @@
+//
+//
+// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
+//
+// using QuickType;
+//
+// var topLevel = TopLevel.FromJson(jsonString);
+#nullable enable
+#pragma warning disable CS8618
+#pragma warning disable CS8601
+#pragma warning disable CS8602
+#pragma warning disable CS8603
+#pragma warning disable CS8604
+#pragma warning disable CS8625
+#pragma warning disable CS8765
+
+namespace QuickType
+{
+ using System;
+ using System.Collections.Generic;
+
+ using System.Globalization;
+ using Newtonsoft.Json;
+ using Newtonsoft.Json.Converters;
+
+ public partial class TopLevel
+ {
+ [JsonProperty("Abranchiata", Required = Required.Always)]
+ public Abranchiata[] Abranchiata { get; set; }
+
+ [JsonProperty("academe", Required = Required.Always)]
+ public Academe[] Academe { get; set; }
+
+ [JsonProperty("acquirable", Required = Required.Always)]
+ public Acquirable[] Acquirable { get; set; }
+
+ [JsonProperty("aerometry", Required = Required.Always)]
+ public Aerometry[] Aerometry { get; set; }
+
+ [JsonProperty("alexin", Required = Required.Always)]
+ public Alexin[] Alexin { get; set; }
+
+ [JsonProperty("alleviate", Required = Required.Always)]
+ public AlleviateElement[] Alleviate { get; set; }
+
+ [JsonProperty("amaas", Required = Required.Always)]
+ public Amaa[] Amaas { get; set; }
+
+ [JsonProperty("ambassage", Required = Required.Always)]
+ public Ambassage[] Ambassage { get; set; }
+
+ [JsonProperty("amphithyron", Required = Required.Always)]
+ public Amphithyron?[] Amphithyron { get; set; }
+
+ [JsonProperty("Andriana", Required = Required.Always)]
+ public string?[] Andriana { get; set; }
+
+ [JsonProperty("ankee", Required = Required.Always)]
+ public AnkeeElement[] Ankee { get; set; }
+
+ [JsonProperty("annihilator", Required = Required.Always)]
+ public Dictionary?[] Annihilator { get; set; }
+
+ [JsonProperty("annulose", Required = Required.AllowNull)]
+ public object Annulose { get; set; }
+
+ [JsonProperty("Ansarie", Required = Required.Always)]
+ public AnsarieElement[] Ansarie { get; set; }
+
+ [JsonProperty("aphasia", Required = Required.Always)]
+ public Aphasia[] Aphasia { get; set; }
+
+ [JsonProperty("asprawl", Required = Required.Always)]
+ public Asprawl[] Asprawl { get; set; }
+
+ [JsonProperty("attractive", Required = Required.Always)]
+ public bool?[] Attractive { get; set; }
+
+ [JsonProperty("barksome", Required = Required.Always)]
+ public Dictionary Barksome { get; set; }
+
+ [JsonProperty("bedesman", Required = Required.Always)]
+ public Bedesman[] Bedesman { get; set; }
+
+ [JsonProperty("belard", Required = Required.Always)]
+ public Belard[] Belard { get; set; }
+
+ [JsonProperty("bocking", Required = Required.Always)]
+ public Bocking[] Bocking { get; set; }
+
+ [JsonProperty("brawlingly", Required = Required.Always)]
+ public Brawlingly[] Brawlingly { get; set; }
+
+ [JsonProperty("brookie", Required = Required.Always)]
+ public Brookie[] Brookie { get; set; }
+
+ [JsonProperty("bumboatman", Required = Required.Always)]
+ public Bumboatman[] Bumboatman { get; set; }
+
+ [JsonProperty("bystreet", Required = Required.Always)]
+ public object[] Bystreet { get; set; }
+
+ [JsonProperty("calaverite", Required = Required.Always)]
+ public Calaverite[] Calaverite { get; set; }
+
+ [JsonProperty("catallactic", Required = Required.Always)]
+ public Catallactic[] Catallactic { get; set; }
+
+ [JsonProperty("cemental", Required = Required.Always)]
+ public Cemental[] Cemental { get; set; }
+
+ [JsonProperty("Chytridiaceae", Required = Required.Always)]
+ public ChytridiaceaeElement[] Chytridiaceae { get; set; }
+
+ [JsonProperty("Discordia", Required = Required.Always)]
+ public DiscordiaElement[] Discordia { get; set; }
+
+ [JsonProperty("Endomyces", Required = Required.Always)]
+ public Endomyce[] Endomyces { get; set; }
+
+ [JsonProperty("Epinephelidae", Required = Required.Always)]
+ public Epinephelidae[] Epinephelidae { get; set; }
+
+ [JsonProperty("Eupatorium", Required = Required.Always)]
+ public Eupatorium[] Eupatorium { get; set; }
+
+ [JsonProperty("Gryphosaurus", Required = Required.Always)]
+ public GryphosaurusElement[] Gryphosaurus { get; set; }
+
+ [JsonProperty("Koryak", Required = Required.Always)]
+ public Koryak[] Koryak { get; set; }
+
+ [JsonProperty("Lavinia", Required = Required.Always)]
+ public LaviniaElement[] Lavinia { get; set; }
+
+ [JsonProperty("Oskar", Required = Required.Always)]
+ public OskarElement[] Oskar { get; set; }
+
+ [JsonProperty("Rebecca", Required = Required.Always)]
+ public RebeccaElement[] Rebecca { get; set; }
+
+ [JsonProperty("Rhomboganoidei", Required = Required.Always)]
+ public Rhomboganoidei[] Rhomboganoidei { get; set; }
+
+ [JsonProperty("Rigsmal", Required = Required.Always)]
+ public bool Rigsmal { get; set; }
+
+ [JsonProperty("Ruellia", Required = Required.Always)]
+ public Ruellia[] Ruellia { get; set; }
+
+ [JsonProperty("School", Required = Required.Always)]
+ public School[] School { get; set; }
+
+ [JsonProperty("Shakespearolater", Required = Required.Always)]
+ public Shakespearolater[] Shakespearolater { get; set; }
+
+ [JsonProperty("Svan", Required = Required.Always)]
+ public double[] Svan { get; set; }
+
+ [JsonProperty("Wayao", Required = Required.Always)]
+ public Dictionary Wayao { get; set; }
+ }
+
+ public partial class AlleviateClass
+ {
+ [JsonProperty("apriori", Required = Required.AllowNull)]
+ public object Apriori { get; set; }
+
+ [JsonProperty("beggarer", Required = Required.AllowNull)]
+ public object Beggarer { get; set; }
+
+ [JsonProperty("brokenheartedly", Required = Required.AllowNull)]
+ public object Brokenheartedly { get; set; }
+
+ [JsonProperty("debilitation", Required = Required.AllowNull)]
+ public object Debilitation { get; set; }
+
+ [JsonProperty("frike", Required = Required.AllowNull)]
+ public object Frike { get; set; }
+
+ [JsonProperty("gastrolith", Required = Required.AllowNull)]
+ public object Gastrolith { get; set; }
+
+ [JsonProperty("Hulsean", Required = Required.AllowNull)]
+ public object Hulsean { get; set; }
+
+ [JsonProperty("orthocentric", Required = Required.AllowNull)]
+ public object Orthocentric { get; set; }
+
+ [JsonProperty("petaly", Required = Required.AllowNull)]
+ public object Petaly { get; set; }
+
+ [JsonProperty("probudgeting", Required = Required.AllowNull)]
+ public object Probudgeting { get; set; }
+
+ [JsonProperty("reacquire", Required = Required.AllowNull)]
+ public object Reacquire { get; set; }
+
+ [JsonProperty("scow", Required = Required.AllowNull)]
+ public object Scow { get; set; }
+
+ [JsonProperty("shutoff", Required = Required.AllowNull)]
+ public object Shutoff { get; set; }
+
+ [JsonProperty("subcontiguous", Required = Required.AllowNull)]
+ public object Subcontiguous { get; set; }
+
+ [JsonProperty("suffumigate", Required = Required.AllowNull)]
+ public object Suffumigate { get; set; }
+
+ [JsonProperty("transformable", Required = Required.AllowNull)]
+ public object Transformable { get; set; }
+
+ [JsonProperty("uncoroneted", Required = Required.AllowNull)]
+ public object Uncoroneted { get; set; }
+
+ [JsonProperty("unparking", Required = Required.AllowNull)]
+ public object Unparking { get; set; }
+
+ [JsonProperty("unvarnishedness", Required = Required.AllowNull)]
+ public object Unvarnishedness { get; set; }
+
+ [JsonProperty("wherewithal", Required = Required.AllowNull)]
+ public object Wherewithal { get; set; }
+ }
+
+ public partial class Rebecca
+ {
+ [JsonProperty("catharticalness", Required = Required.Always)]
+ public double Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", Required = Required.Always)]
+ public long Chirotherium { get; set; }
+
+ [JsonProperty("disdiapason", Required = Required.Always)]
+ public string Disdiapason { get; set; }
+
+ [JsonProperty("homocerc", Required = Required.Always)]
+ public bool Homocerc { get; set; }
+
+ [JsonProperty("nonbookish", Required = Required.AllowNull)]
+ public object Nonbookish { get; set; }
+ }
+
+ public partial class Amphithyron
+ {
+ [JsonProperty("akroasis", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Akroasis { get; set; }
+
+ [JsonProperty("antiphonical", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Antiphonical { get; set; }
+
+ [JsonProperty("basebred", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Basebred { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("conductometric", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Conductometric { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("ensilation", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Ensilation { get; set; }
+
+ [JsonProperty("eyebolt", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Eyebolt { get; set; }
+
+ [JsonProperty("fistulated", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Fistulated { get; set; }
+
+ [JsonProperty("heteropod", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Heteropod { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("Juniperus", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Juniperus { get; set; }
+
+ [JsonProperty("labyrinthically", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Labyrinthically { get; set; }
+
+ [JsonProperty("martyrization", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Martyrization { get; set; }
+
+ [JsonProperty("mispolicy", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Mispolicy { get; set; }
+
+ [JsonProperty("multipara", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Multipara { get; set; }
+
+ [JsonProperty("Nazirite", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Nazirite { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("possessorial", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Possessorial { get; set; }
+
+ [JsonProperty("shamed", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Shamed { get; set; }
+
+ [JsonProperty("shelfworn", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Shelfworn { get; set; }
+
+ [JsonProperty("stagnum", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Stagnum { get; set; }
+
+ [JsonProperty("Those", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Those { get; set; }
+
+ [JsonProperty("undecimal", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Undecimal { get; set; }
+ }
+
+ public partial class AnkeeClass
+ {
+ [JsonProperty("Anomoean", Required = Required.AllowNull)]
+ public object Anomoean { get; set; }
+
+ [JsonProperty("barleyhood", Required = Required.AllowNull)]
+ public object Barleyhood { get; set; }
+
+ [JsonProperty("befriender", Required = Required.AllowNull)]
+ public object Befriender { get; set; }
+
+ [JsonProperty("brutishness", Required = Required.AllowNull)]
+ public object Brutishness { get; set; }
+
+ [JsonProperty("cephalalgy", Required = Required.AllowNull)]
+ public object Cephalalgy { get; set; }
+
+ [JsonProperty("cirurgian", Required = Required.AllowNull)]
+ public object Cirurgian { get; set; }
+
+ [JsonProperty("conventionally", Required = Required.AllowNull)]
+ public object Conventionally { get; set; }
+
+ [JsonProperty("jackshay", Required = Required.AllowNull)]
+ public object Jackshay { get; set; }
+
+ [JsonProperty("milammeter", Required = Required.AllowNull)]
+ public object Milammeter { get; set; }
+
+ [JsonProperty("Naja", Required = Required.AllowNull)]
+ public object Naja { get; set; }
+
+ [JsonProperty("ombrological", Required = Required.AllowNull)]
+ public object Ombrological { get; set; }
+
+ [JsonProperty("phonasthenia", Required = Required.AllowNull)]
+ public object Phonasthenia { get; set; }
+
+ [JsonProperty("retrievableness", Required = Required.AllowNull)]
+ public object Retrievableness { get; set; }
+
+ [JsonProperty("snakily", Required = Required.AllowNull)]
+ public object Snakily { get; set; }
+
+ [JsonProperty("swot", Required = Required.AllowNull)]
+ public object Swot { get; set; }
+
+ [JsonProperty("tartlet", Required = Required.AllowNull)]
+ public object Tartlet { get; set; }
+
+ [JsonProperty("thiofuran", Required = Required.AllowNull)]
+ public object Thiofuran { get; set; }
+
+ [JsonProperty("tracheophone", Required = Required.AllowNull)]
+ public object Tracheophone { get; set; }
+
+ [JsonProperty("tuglike", Required = Required.AllowNull)]
+ public object Tuglike { get; set; }
+
+ [JsonProperty("unscratchingly", Required = Required.AllowNull)]
+ public object Unscratchingly { get; set; }
+ }
+
+ public partial class AnsarieClass
+ {
+ [JsonProperty("accension", Required = Required.AllowNull)]
+ public object Accension { get; set; }
+
+ [JsonProperty("Alida", Required = Required.AllowNull)]
+ public object Alida { get; set; }
+
+ [JsonProperty("asteria", Required = Required.AllowNull)]
+ public object Asteria { get; set; }
+
+ [JsonProperty("beriberic", Required = Required.AllowNull)]
+ public object Beriberic { get; set; }
+
+ [JsonProperty("edgebone", Required = Required.AllowNull)]
+ public object Edgebone { get; set; }
+
+ [JsonProperty("gastrodialysis", Required = Required.AllowNull)]
+ public object Gastrodialysis { get; set; }
+
+ [JsonProperty("geographic", Required = Required.AllowNull)]
+ public object Geographic { get; set; }
+
+ [JsonProperty("Ictonyx", Required = Required.AllowNull)]
+ public object Ictonyx { get; set; }
+
+ [JsonProperty("metrocele", Required = Required.AllowNull)]
+ public object Metrocele { get; set; }
+
+ [JsonProperty("misgraft", Required = Required.AllowNull)]
+ public object Misgraft { get; set; }
+
+ [JsonProperty("monteith", Required = Required.AllowNull)]
+ public object Monteith { get; set; }
+
+ [JsonProperty("notcher", Required = Required.AllowNull)]
+ public object Notcher { get; set; }
+
+ [JsonProperty("prorestriction", Required = Required.AllowNull)]
+ public object Prorestriction { get; set; }
+
+ [JsonProperty("Ramist", Required = Required.AllowNull)]
+ public object Ramist { get; set; }
+
+ [JsonProperty("throatlet", Required = Required.AllowNull)]
+ public object Throatlet { get; set; }
+
+ [JsonProperty("unfair", Required = Required.AllowNull)]
+ public object Unfair { get; set; }
+
+ [JsonProperty("unsynonymous", Required = Required.AllowNull)]
+ public object Unsynonymous { get; set; }
+
+ [JsonProperty("water", Required = Required.AllowNull)]
+ public object Water { get; set; }
+
+ [JsonProperty("zestfully", Required = Required.AllowNull)]
+ public object Zestfully { get; set; }
+
+ [JsonProperty("zincic", Required = Required.AllowNull)]
+ public object Zincic { get; set; }
+ }
+
+ public partial class ChytridiaceaeClass
+ {
+ [JsonProperty("Batidaceae", Required = Required.AllowNull)]
+ public object Batidaceae { get; set; }
+
+ [JsonProperty("Brechites", Required = Required.AllowNull)]
+ public object Brechites { get; set; }
+
+ [JsonProperty("codespairer", Required = Required.AllowNull)]
+ public object Codespairer { get; set; }
+
+ [JsonProperty("Emery", Required = Required.AllowNull)]
+ public object Emery { get; set; }
+
+ [JsonProperty("enervative", Required = Required.AllowNull)]
+ public object Enervative { get; set; }
+
+ [JsonProperty("excriminate", Required = Required.AllowNull)]
+ public object Excriminate { get; set; }
+
+ [JsonProperty("goshenite", Required = Required.AllowNull)]
+ public object Goshenite { get; set; }
+
+ [JsonProperty("grime", Required = Required.AllowNull)]
+ public object Grime { get; set; }
+
+ [JsonProperty("gritten", Required = Required.AllowNull)]
+ public object Gritten { get; set; }
+
+ [JsonProperty("hectorly", Required = Required.AllowNull)]
+ public object Hectorly { get; set; }
+
+ [JsonProperty("intermediation", Required = Required.AllowNull)]
+ public object Intermediation { get; set; }
+
+ [JsonProperty("meeterly", Required = Required.AllowNull)]
+ public object Meeterly { get; set; }
+
+ [JsonProperty("Narraganset", Required = Required.AllowNull)]
+ public object Narraganset { get; set; }
+
+ [JsonProperty("onymatic", Required = Required.AllowNull)]
+ public object Onymatic { get; set; }
+
+ [JsonProperty("paddlecock", Required = Required.AllowNull)]
+ public object Paddlecock { get; set; }
+
+ [JsonProperty("thana", Required = Required.AllowNull)]
+ public object Thana { get; set; }
+
+ [JsonProperty("thornily", Required = Required.AllowNull)]
+ public object Thornily { get; set; }
+
+ [JsonProperty("uckia", Required = Required.AllowNull)]
+ public object Uckia { get; set; }
+
+ [JsonProperty("unmettle", Required = Required.AllowNull)]
+ public object Unmettle { get; set; }
+
+ [JsonProperty("vorticellid", Required = Required.AllowNull)]
+ public object Vorticellid { get; set; }
+ }
+
+ public partial class DiscordiaClass
+ {
+ [JsonProperty("Altaic", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Altaic { get; set; }
+
+ [JsonProperty("amoristic", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Amoristic { get; set; }
+
+ [JsonProperty("blennophthalmia", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Blennophthalmia { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("disciplinability", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Disciplinability { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("goofer", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Goofer { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("laryngograph", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Laryngograph { get; set; }
+
+ [JsonProperty("leucitis", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Leucitis { get; set; }
+
+ [JsonProperty("lymphocyst", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Lymphocyst { get; set; }
+
+ [JsonProperty("microcosmology", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Microcosmology { get; set; }
+
+ [JsonProperty("nauseation", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Nauseation { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("Patarin", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Patarin { get; set; }
+
+ [JsonProperty("preliberal", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Preliberal { get; set; }
+
+ [JsonProperty("prettifier", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Prettifier { get; set; }
+
+ [JsonProperty("rangework", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Rangework { get; set; }
+
+ [JsonProperty("redient", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Redient { get; set; }
+
+ [JsonProperty("subfusiform", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Subfusiform { get; set; }
+
+ [JsonProperty("suicidical", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Suicidical { get; set; }
+
+ [JsonProperty("swow", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Swow { get; set; }
+
+ [JsonProperty("wastrel", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Wastrel { get; set; }
+
+ [JsonProperty("wingle", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Wingle { get; set; }
+ }
+
+ public partial class GryphosaurusClass
+ {
+ [JsonProperty("amissibility", Required = Required.AllowNull)]
+ public object Amissibility { get; set; }
+
+ [JsonProperty("Burushaski", Required = Required.AllowNull)]
+ public object Burushaski { get; set; }
+
+ [JsonProperty("citronin", Required = Required.AllowNull)]
+ public object Citronin { get; set; }
+
+ [JsonProperty("coplaintiff", Required = Required.AllowNull)]
+ public object Coplaintiff { get; set; }
+
+ [JsonProperty("disquisitionary", Required = Required.AllowNull)]
+ public object Disquisitionary { get; set; }
+
+ [JsonProperty("enoplan", Required = Required.AllowNull)]
+ public object Enoplan { get; set; }
+
+ [JsonProperty("faintness", Required = Required.AllowNull)]
+ public object Faintness { get; set; }
+
+ [JsonProperty("hebetomy", Required = Required.AllowNull)]
+ public object Hebetomy { get; set; }
+
+ [JsonProperty("islandry", Required = Required.AllowNull)]
+ public object Islandry { get; set; }
+
+ [JsonProperty("lameduck", Required = Required.AllowNull)]
+ public object Lameduck { get; set; }
+
+ [JsonProperty("overbattle", Required = Required.AllowNull)]
+ public object Overbattle { get; set; }
+
+ [JsonProperty("overinterested", Required = Required.AllowNull)]
+ public object Overinterested { get; set; }
+
+ [JsonProperty("phrenologic", Required = Required.AllowNull)]
+ public object Phrenologic { get; set; }
+
+ [JsonProperty("rainband", Required = Required.AllowNull)]
+ public object Rainband { get; set; }
+
+ [JsonProperty("shiningly", Required = Required.AllowNull)]
+ public object Shiningly { get; set; }
+
+ [JsonProperty("stamineous", Required = Required.AllowNull)]
+ public object Stamineous { get; set; }
+
+ [JsonProperty("subscapularis", Required = Required.AllowNull)]
+ public object Subscapularis { get; set; }
+
+ [JsonProperty("Tahami", Required = Required.AllowNull)]
+ public object Tahami { get; set; }
+
+ [JsonProperty("undaubed", Required = Required.AllowNull)]
+ public object Undaubed { get; set; }
+
+ [JsonProperty("underntime", Required = Required.AllowNull)]
+ public object Underntime { get; set; }
+ }
+
+ public partial class LaviniaClass
+ {
+ [JsonProperty("agitable", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Agitable { get; set; }
+
+ [JsonProperty("asininity", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Asininity { get; set; }
+
+ [JsonProperty("benefiter", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Benefiter { get; set; }
+
+ [JsonProperty("bronzelike", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Bronzelike { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("cholesteatomatous", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Cholesteatomatous { get; set; }
+
+ [JsonProperty("deprivement", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Deprivement { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("flippantness", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Flippantness { get; set; }
+
+ [JsonProperty("fogproof", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Fogproof { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("merrymeeting", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Merrymeeting { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("overcareful", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Overcareful { get; set; }
+
+ [JsonProperty("panaris", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Panaris { get; set; }
+
+ [JsonProperty("preacceptance", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Preacceptance { get; set; }
+
+ [JsonProperty("quinoxaline", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Quinoxaline { get; set; }
+
+ [JsonProperty("sig", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Sig { get; set; }
+
+ [JsonProperty("superconfusion", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Superconfusion { get; set; }
+
+ [JsonProperty("Tacana", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Tacana { get; set; }
+
+ [JsonProperty("tillotter", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Tillotter { get; set; }
+
+ [JsonProperty("tranquillize", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Tranquillize { get; set; }
+
+ [JsonProperty("unquestionable", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Unquestionable { get; set; }
+
+ [JsonProperty("uproute", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Uproute { get; set; }
+ }
+
+ public partial class OskarClass
+ {
+ [JsonProperty("Acrobates", Required = Required.AllowNull)]
+ public object Acrobates { get; set; }
+
+ [JsonProperty("beanshooter", Required = Required.AllowNull)]
+ public object Beanshooter { get; set; }
+
+ [JsonProperty("bearhound", Required = Required.AllowNull)]
+ public object Bearhound { get; set; }
+
+ [JsonProperty("Cayuga", Required = Required.AllowNull)]
+ public object Cayuga { get; set; }
+
+ [JsonProperty("guarneri", Required = Required.AllowNull)]
+ public object Guarneri { get; set; }
+
+ [JsonProperty("hypochondriacism", Required = Required.AllowNull)]
+ public object Hypochondriacism { get; set; }
+
+ [JsonProperty("indication", Required = Required.AllowNull)]
+ public object Indication { get; set; }
+
+ [JsonProperty("jaculative", Required = Required.AllowNull)]
+ public object Jaculative { get; set; }
+
+ [JsonProperty("nagana", Required = Required.AllowNull)]
+ public object Nagana { get; set; }
+
+ [JsonProperty("Netherlandish", Required = Required.AllowNull)]
+ public object Netherlandish { get; set; }
+
+ [JsonProperty("noctivagous", Required = Required.AllowNull)]
+ public object Noctivagous { get; set; }
+
+ [JsonProperty("nonphysiological", Required = Required.AllowNull)]
+ public object Nonphysiological { get; set; }
+
+ [JsonProperty("praxis", Required = Required.AllowNull)]
+ public object Praxis { get; set; }
+
+ [JsonProperty("provision", Required = Required.AllowNull)]
+ public object Provision { get; set; }
+
+ [JsonProperty("subterhuman", Required = Required.AllowNull)]
+ public object Subterhuman { get; set; }
+
+ [JsonProperty("sunlit", Required = Required.AllowNull)]
+ public object Sunlit { get; set; }
+
+ [JsonProperty("syncraniate", Required = Required.AllowNull)]
+ public object Syncraniate { get; set; }
+
+ [JsonProperty("teachment", Required = Required.AllowNull)]
+ public object Teachment { get; set; }
+
+ [JsonProperty("unmutinous", Required = Required.AllowNull)]
+ public object Unmutinous { get; set; }
+
+ [JsonProperty("unstoppable", Required = Required.AllowNull)]
+ public object Unstoppable { get; set; }
+ }
+
+ public partial struct Abranchiata
+ {
+ public long? Integer;
+ public long[]? IntegerArray;
+
+ public static implicit operator Abranchiata(long Integer) => new Abranchiata { Integer = Integer };
+ public static implicit operator Abranchiata(long[] IntegerArray) => new Abranchiata { IntegerArray = IntegerArray };
+ public bool IsNull => IntegerArray == null && Integer == null;
+ }
+
+ public partial struct Academe
+ {
+ public long? Integer;
+ public long[]? IntegerArray;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Academe(long Integer) => new Academe { Integer = Integer };
+ public static implicit operator Academe(long[] IntegerArray) => new Academe { IntegerArray = IntegerArray };
+ public static implicit operator Academe(Dictionary IntegerMap) => new Academe { IntegerMap = IntegerMap };
+ }
+
+ public partial struct Acquirable
+ {
+ public Dictionary? IntegerMap;
+ public long?[]? UnionArray;
+
+ public static implicit operator Acquirable(Dictionary IntegerMap) => new Acquirable { IntegerMap = IntegerMap };
+ public static implicit operator Acquirable(long?[] UnionArray) => new Acquirable { UnionArray = UnionArray };
+ }
+
+ public partial struct Aerometry
+ {
+ public bool? Bool;
+ public double? Double;
+
+ public static implicit operator Aerometry(bool Bool) => new Aerometry { Bool = Bool };
+ public static implicit operator Aerometry(double Double) => new Aerometry { Double = Double };
+ }
+
+ public partial struct Alexin
+ {
+ public bool? Bool;
+ public long[]? IntegerArray;
+
+ public static implicit operator Alexin(bool Bool) => new Alexin { Bool = Bool };
+ public static implicit operator Alexin(long[] IntegerArray) => new Alexin { IntegerArray = IntegerArray };
+ }
+
+ public partial struct AlleviateElement
+ {
+ public AlleviateClass? AlleviateClass;
+ public long?[]? UnionArray;
+
+ public static implicit operator AlleviateElement(AlleviateClass AlleviateClass) => new AlleviateElement { AlleviateClass = AlleviateClass };
+ public static implicit operator AlleviateElement(long?[] UnionArray) => new AlleviateElement { UnionArray = UnionArray };
+ }
+
+ public partial struct Amaa
+ {
+ public bool? Bool;
+ public long? Integer;
+ public Rebecca? Rebecca;
+
+ public static implicit operator Amaa(bool Bool) => new Amaa { Bool = Bool };
+ public static implicit operator Amaa(long Integer) => new Amaa { Integer = Integer };
+ public static implicit operator Amaa(Rebecca Rebecca) => new Amaa { Rebecca = Rebecca };
+ }
+
+ public partial struct Ambassage
+ {
+ public object[]? NullArray;
+ public string? String;
+
+ public static implicit operator Ambassage(object[] NullArray) => new Ambassage { NullArray = NullArray };
+ public static implicit operator Ambassage(string String) => new Ambassage { String = String };
+ }
+
+ public partial struct AnkeeElement
+ {
+ public AnkeeClass? AnkeeClass;
+ public long? Integer;
+ public long[]? IntegerArray;
+
+ public static implicit operator AnkeeElement(AnkeeClass AnkeeClass) => new AnkeeElement { AnkeeClass = AnkeeClass };
+ public static implicit operator AnkeeElement(long Integer) => new AnkeeElement { Integer = Integer };
+ public static implicit operator AnkeeElement(long[] IntegerArray) => new AnkeeElement { IntegerArray = IntegerArray };
+ }
+
+ public partial struct AnsarieElement
+ {
+ public AnsarieClass? AnsarieClass;
+ public long[]? IntegerArray;
+
+ public static implicit operator AnsarieElement(AnsarieClass AnsarieClass) => new AnsarieElement { AnsarieClass = AnsarieClass };
+ public static implicit operator AnsarieElement(long[] IntegerArray) => new AnsarieElement { IntegerArray = IntegerArray };
+ public bool IsNull => IntegerArray == null && AnsarieClass == null;
+ }
+
+ public partial struct Aphasia
+ {
+ public long? Integer;
+ public long[]? IntegerArray;
+
+ public static implicit operator Aphasia(long Integer) => new Aphasia { Integer = Integer };
+ public static implicit operator Aphasia(long[] IntegerArray) => new Aphasia { IntegerArray = IntegerArray };
+ }
+
+ public partial struct Asprawl
+ {
+ public double? Double;
+ public string? String;
+
+ public static implicit operator Asprawl(double Double) => new Asprawl { Double = Double };
+ public static implicit operator Asprawl(string String) => new Asprawl { String = String };
+ }
+
+ public partial struct Bedesman
+ {
+ public bool? Bool;
+ public double? Double;
+ public string? String;
+
+ public static implicit operator Bedesman(bool Bool) => new Bedesman { Bool = Bool };
+ public static implicit operator Bedesman(double Double) => new Bedesman { Double = Double };
+ public static implicit operator Bedesman(string String) => new Bedesman { String = String };
+ }
+
+ public partial struct Belard
+ {
+ public double? Double;
+ public long[]? IntegerArray;
+ public Rebecca? Rebecca;
+
+ public static implicit operator Belard(double Double) => new Belard { Double = Double };
+ public static implicit operator Belard(long[] IntegerArray) => new Belard { IntegerArray = IntegerArray };
+ public static implicit operator Belard(Rebecca Rebecca) => new Belard { Rebecca = Rebecca };
+ }
+
+ public partial struct Bocking
+ {
+ public bool? Bool;
+ public long[]? IntegerArray;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Bocking(bool Bool) => new Bocking { Bool = Bool };
+ public static implicit operator Bocking(long[] IntegerArray) => new Bocking { IntegerArray = IntegerArray };
+ public static implicit operator Bocking(Dictionary IntegerMap) => new Bocking { IntegerMap = IntegerMap };
+ }
+
+ public partial struct Brawlingly
+ {
+ public object[]? NullArray;
+ public Dictionary? UnionMap;
+
+ public static implicit operator Brawlingly(object[] NullArray) => new Brawlingly { NullArray = NullArray };
+ public static implicit operator Brawlingly(Dictionary UnionMap) => new Brawlingly { UnionMap = UnionMap };
+ }
+
+ public partial struct Brookie
+ {
+ public long[]? IntegerArray;
+ public Rebecca? Rebecca;
+
+ public static implicit operator Brookie(long[] IntegerArray) => new Brookie { IntegerArray = IntegerArray };
+ public static implicit operator Brookie(Rebecca Rebecca) => new Brookie { Rebecca = Rebecca };
+ }
+
+ public partial struct Bumboatman
+ {
+ public object[]? NullArray;
+ public string? String;
+
+ public static implicit operator Bumboatman(object[] NullArray) => new Bumboatman { NullArray = NullArray };
+ public static implicit operator Bumboatman(string String) => new Bumboatman { String = String };
+ public bool IsNull => NullArray == null && String == null;
+ }
+
+ public partial struct Calaverite
+ {
+ public long[]? IntegerArray;
+ public string? String;
+
+ public static implicit operator Calaverite(long[] IntegerArray) => new Calaverite { IntegerArray = IntegerArray };
+ public static implicit operator Calaverite(string String) => new Calaverite { String = String };
+ }
+
+ public partial struct Catallactic
+ {
+ public bool? Bool;
+ public Dictionary? IntegerMap;
+ public object[]? NullArray;
+
+ public static implicit operator Catallactic(bool Bool) => new Catallactic { Bool = Bool };
+ public static implicit operator Catallactic(Dictionary IntegerMap) => new Catallactic { IntegerMap = IntegerMap };
+ public static implicit operator Catallactic(object[] NullArray) => new Catallactic { NullArray = NullArray };
+ }
+
+ public partial struct Cemental
+ {
+ public double? Double;
+ public long[]? IntegerArray;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Cemental(double Double) => new Cemental { Double = Double };
+ public static implicit operator Cemental(long[] IntegerArray) => new Cemental { IntegerArray = IntegerArray };
+ public static implicit operator Cemental(Dictionary IntegerMap) => new Cemental { IntegerMap = IntegerMap };
+ }
+
+ public partial struct ChytridiaceaeElement
+ {
+ public bool? Bool;
+ public ChytridiaceaeClass? ChytridiaceaeClass;
+
+ public static implicit operator ChytridiaceaeElement(bool Bool) => new ChytridiaceaeElement { Bool = Bool };
+ public static implicit operator ChytridiaceaeElement(ChytridiaceaeClass ChytridiaceaeClass) => new ChytridiaceaeElement { ChytridiaceaeClass = ChytridiaceaeClass };
+ public bool IsNull => Bool == null && ChytridiaceaeClass == null;
+ }
+
+ public partial struct DiscordiaElement
+ {
+ public DiscordiaClass? DiscordiaClass;
+ public long[]? IntegerArray;
+
+ public static implicit operator DiscordiaElement(DiscordiaClass DiscordiaClass) => new DiscordiaElement { DiscordiaClass = DiscordiaClass };
+ public static implicit operator DiscordiaElement(long[] IntegerArray) => new DiscordiaElement { IntegerArray = IntegerArray };
+ }
+
+ public partial struct Endomyce
+ {
+ public long? Integer;
+ public string? String;
+
+ public static implicit operator Endomyce(long Integer) => new Endomyce { Integer = Integer };
+ public static implicit operator Endomyce(string String) => new Endomyce { String = String };
+ }
+
+ public partial struct Epinephelidae
+ {
+ public bool? Bool;
+ public long? Integer;
+ public string? String;
+
+ public static implicit operator Epinephelidae(bool Bool) => new Epinephelidae { Bool = Bool };
+ public static implicit operator Epinephelidae(long Integer) => new Epinephelidae { Integer = Integer };
+ public static implicit operator Epinephelidae(string String) => new Epinephelidae { String = String };
+ }
+
+ public partial struct Eupatorium
+ {
+ public Dictionary? IntegerMap;
+ public object[]? NullArray;
+
+ public static implicit operator Eupatorium(Dictionary IntegerMap) => new Eupatorium { IntegerMap = IntegerMap };
+ public static implicit operator Eupatorium(object[] NullArray) => new Eupatorium { NullArray = NullArray };
+ }
+
+ public partial struct GryphosaurusElement
+ {
+ public GryphosaurusClass? GryphosaurusClass;
+ public long[]? IntegerArray;
+ public string? String;
+
+ public static implicit operator GryphosaurusElement(GryphosaurusClass GryphosaurusClass) => new GryphosaurusElement { GryphosaurusClass = GryphosaurusClass };
+ public static implicit operator GryphosaurusElement(long[] IntegerArray) => new GryphosaurusElement { IntegerArray = IntegerArray };
+ public static implicit operator GryphosaurusElement(string String) => new GryphosaurusElement { String = String };
+ }
+
+ public partial struct Koryak
+ {
+ public string? String;
+ public Dictionary? UnionMap;
+
+ public static implicit operator Koryak(string String) => new Koryak { String = String };
+ public static implicit operator Koryak(Dictionary UnionMap) => new Koryak { UnionMap = UnionMap };
+ }
+
+ public partial struct LaviniaElement
+ {
+ public LaviniaClass? LaviniaClass;
+ public string? String;
+
+ public static implicit operator LaviniaElement(LaviniaClass LaviniaClass) => new LaviniaElement { LaviniaClass = LaviniaClass };
+ public static implicit operator LaviniaElement(string String) => new LaviniaElement { String = String };
+ }
+
+ public partial struct OskarElement
+ {
+ public long[]? IntegerArray;
+ public OskarClass? OskarClass;
+
+ public static implicit operator OskarElement(long[] IntegerArray) => new OskarElement { IntegerArray = IntegerArray };
+ public static implicit operator OskarElement(OskarClass OskarClass) => new OskarElement { OskarClass = OskarClass };
+ }
+
+ public partial struct RebeccaElement
+ {
+ public long? Integer;
+ public Rebecca? Rebecca;
+ public string? String;
+
+ public static implicit operator RebeccaElement(long Integer) => new RebeccaElement { Integer = Integer };
+ public static implicit operator RebeccaElement(Rebecca Rebecca) => new RebeccaElement { Rebecca = Rebecca };
+ public static implicit operator RebeccaElement(string String) => new RebeccaElement { String = String };
+ }
+
+ public partial struct Rhomboganoidei
+ {
+ public long[]? IntegerArray;
+ public Rebecca? Rebecca;
+ public string? String;
+
+ public static implicit operator Rhomboganoidei(long[] IntegerArray) => new Rhomboganoidei { IntegerArray = IntegerArray };
+ public static implicit operator Rhomboganoidei(Rebecca Rebecca) => new Rhomboganoidei { Rebecca = Rebecca };
+ public static implicit operator Rhomboganoidei(string String) => new Rhomboganoidei { String = String };
+ }
+
+ public partial struct Ruellia
+ {
+ public bool? Bool;
+ public Rebecca? Rebecca;
+ public string? String;
+
+ public static implicit operator Ruellia(bool Bool) => new Ruellia { Bool = Bool };
+ public static implicit operator Ruellia(Rebecca Rebecca) => new Ruellia { Rebecca = Rebecca };
+ public static implicit operator Ruellia(string String) => new Ruellia { String = String };
+ }
+
+ public partial struct School
+ {
+ public long? Integer;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator School(long Integer) => new School { Integer = Integer };
+ public static implicit operator School(Dictionary IntegerMap) => new School { IntegerMap = IntegerMap };
+ public bool IsNull => Integer == null && IntegerMap == null;
+ }
+
+ public partial struct Shakespearolater
+ {
+ public double? Double;
+ public long[]? IntegerArray;
+ public string? String;
+
+ public static implicit operator Shakespearolater(double Double) => new Shakespearolater { Double = Double };
+ public static implicit operator Shakespearolater(long[] IntegerArray) => new Shakespearolater { IntegerArray = IntegerArray };
+ public static implicit operator Shakespearolater(string String) => new Shakespearolater { String = String };
+ }
+
+ public partial class TopLevel
+ {
+ public static TopLevel? FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings);
+ }
+
+ public static partial class Serialize
+ {
+ public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
+ }
+
+ internal static partial class Converter
+ {
+ public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
+ {
+ MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
+ DateParseHandling = DateParseHandling.None,
+ Converters =
+ {
+ AbranchiataConverter.Singleton,
+ AnsarieElementConverter.Singleton,
+ ChytridiaceaeElementConverter.Singleton,
+ DiscordiaElementConverter.Singleton,
+ EndomyceConverter.Singleton,
+ EpinephelidaeConverter.Singleton,
+ EupatoriumConverter.Singleton,
+ GryphosaurusElementConverter.Singleton,
+ KoryakConverter.Singleton,
+ LaviniaElementConverter.Singleton,
+ OskarElementConverter.Singleton,
+ RebeccaElementConverter.Singleton,
+ RhomboganoideiConverter.Singleton,
+ RuelliaConverter.Singleton,
+ SchoolConverter.Singleton,
+ ShakespearolaterConverter.Singleton,
+ AcademeConverter.Singleton,
+ AcquirableConverter.Singleton,
+ AerometryConverter.Singleton,
+ AlexinConverter.Singleton,
+ AlleviateElementConverter.Singleton,
+ AmaaConverter.Singleton,
+ AmbassageConverter.Singleton,
+ AnkeeElementConverter.Singleton,
+ AphasiaConverter.Singleton,
+ AsprawlConverter.Singleton,
+ BedesmanConverter.Singleton,
+ BelardConverter.Singleton,
+ BockingConverter.Singleton,
+ BrawlinglyConverter.Singleton,
+ BrookieConverter.Singleton,
+ BumboatmanConverter.Singleton,
+ CalaveriteConverter.Singleton,
+ CatallacticConverter.Singleton,
+ CementalConverter.Singleton,
+ new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
+ },
+ };
+ }
+
+ internal class AbranchiataConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Abranchiata) || t == typeof(Abranchiata?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Abranchiata { };
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Abranchiata { Integer = integerValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Abranchiata { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Abranchiata");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Abranchiata)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Abranchiata");
+ }
+
+ public static readonly AbranchiataConverter Singleton = new AbranchiataConverter();
+ }
+
+ internal class AnsarieElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(AnsarieElement) || t == typeof(AnsarieElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new AnsarieElement { };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new AnsarieElement { AnsarieClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new AnsarieElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type AnsarieElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (AnsarieElement)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.AnsarieClass != null)
+ {
+ serializer.Serialize(writer, value.AnsarieClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type AnsarieElement");
+ }
+
+ public static readonly AnsarieElementConverter Singleton = new AnsarieElementConverter();
+ }
+
+ internal class ChytridiaceaeElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(ChytridiaceaeElement) || t == typeof(ChytridiaceaeElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new ChytridiaceaeElement { };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new ChytridiaceaeElement { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new ChytridiaceaeElement { ChytridiaceaeClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type ChytridiaceaeElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (ChytridiaceaeElement)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.ChytridiaceaeClass != null)
+ {
+ serializer.Serialize(writer, value.ChytridiaceaeClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type ChytridiaceaeElement");
+ }
+
+ public static readonly ChytridiaceaeElementConverter Singleton = new ChytridiaceaeElementConverter();
+ }
+
+ internal class DiscordiaElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(DiscordiaElement) || t == typeof(DiscordiaElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new DiscordiaElement { DiscordiaClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new DiscordiaElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type DiscordiaElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (DiscordiaElement)untypedValue;
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.DiscordiaClass != null)
+ {
+ serializer.Serialize(writer, value.DiscordiaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type DiscordiaElement");
+ }
+
+ public static readonly DiscordiaElementConverter Singleton = new DiscordiaElementConverter();
+ }
+
+ internal class EndomyceConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Endomyce) || t == typeof(Endomyce?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Endomyce { Integer = integerValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Endomyce { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Endomyce");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Endomyce)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Endomyce");
+ }
+
+ public static readonly EndomyceConverter Singleton = new EndomyceConverter();
+ }
+
+ internal class EpinephelidaeConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Epinephelidae) || t == typeof(Epinephelidae?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Epinephelidae { Integer = integerValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Epinephelidae { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Epinephelidae { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Epinephelidae");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Epinephelidae)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Epinephelidae");
+ }
+
+ public static readonly EpinephelidaeConverter Singleton = new EpinephelidaeConverter();
+ }
+
+ internal class EupatoriumConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Eupatorium) || t == typeof(Eupatorium?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Eupatorium { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Eupatorium { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Eupatorium");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Eupatorium)untypedValue;
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Eupatorium");
+ }
+
+ public static readonly EupatoriumConverter Singleton = new EupatoriumConverter();
+ }
+
+ internal class GryphosaurusElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(GryphosaurusElement) || t == typeof(GryphosaurusElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new GryphosaurusElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new GryphosaurusElement { GryphosaurusClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new GryphosaurusElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type GryphosaurusElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (GryphosaurusElement)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.GryphosaurusClass != null)
+ {
+ serializer.Serialize(writer, value.GryphosaurusClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type GryphosaurusElement");
+ }
+
+ public static readonly GryphosaurusElementConverter Singleton = new GryphosaurusElementConverter();
+ }
+
+ internal class KoryakConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Koryak) || t == typeof(Koryak?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Koryak { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Koryak { UnionMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Koryak");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Koryak)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.UnionMap != null)
+ {
+ serializer.Serialize(writer, value.UnionMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Koryak");
+ }
+
+ public static readonly KoryakConverter Singleton = new KoryakConverter();
+ }
+
+ internal class LaviniaElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(LaviniaElement) || t == typeof(LaviniaElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new LaviniaElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new LaviniaElement { LaviniaClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type LaviniaElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (LaviniaElement)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.LaviniaClass != null)
+ {
+ serializer.Serialize(writer, value.LaviniaClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type LaviniaElement");
+ }
+
+ public static readonly LaviniaElementConverter Singleton = new LaviniaElementConverter();
+ }
+
+ internal class OskarElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(OskarElement) || t == typeof(OskarElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new OskarElement { OskarClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new OskarElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type OskarElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (OskarElement)untypedValue;
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.OskarClass != null)
+ {
+ serializer.Serialize(writer, value.OskarClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type OskarElement");
+ }
+
+ public static readonly OskarElementConverter Singleton = new OskarElementConverter();
+ }
+
+ internal class RebeccaElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(RebeccaElement) || t == typeof(RebeccaElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new RebeccaElement { Integer = integerValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new RebeccaElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new RebeccaElement { Rebecca = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type RebeccaElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (RebeccaElement)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.Rebecca != null)
+ {
+ serializer.Serialize(writer, value.Rebecca);
+ return;
+ }
+ throw new Exception("Cannot marshal type RebeccaElement");
+ }
+
+ public static readonly RebeccaElementConverter Singleton = new RebeccaElementConverter();
+ }
+
+ internal class RhomboganoideiConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Rhomboganoidei) || t == typeof(Rhomboganoidei?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Rhomboganoidei { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Rhomboganoidei { Rebecca = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Rhomboganoidei { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Rhomboganoidei");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Rhomboganoidei)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.Rebecca != null)
+ {
+ serializer.Serialize(writer, value.Rebecca);
+ return;
+ }
+ throw new Exception("Cannot marshal type Rhomboganoidei");
+ }
+
+ public static readonly RhomboganoideiConverter Singleton = new RhomboganoideiConverter();
+ }
+
+ internal class RuelliaConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Ruellia) || t == typeof(Ruellia?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Ruellia { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Ruellia { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Ruellia { Rebecca = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Ruellia");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Ruellia)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.Rebecca != null)
+ {
+ serializer.Serialize(writer, value.Rebecca);
+ return;
+ }
+ throw new Exception("Cannot marshal type Ruellia");
+ }
+
+ public static readonly RuelliaConverter Singleton = new RuelliaConverter();
+ }
+
+ internal class SchoolConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(School) || t == typeof(School?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new School { };
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new School { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new School { IntegerMap = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type School");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (School)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type School");
+ }
+
+ public static readonly SchoolConverter Singleton = new SchoolConverter();
+ }
+
+ internal class ShakespearolaterConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Shakespearolater) || t == typeof(Shakespearolater?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Shakespearolater { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Shakespearolater { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Shakespearolater { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Shakespearolater");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Shakespearolater)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Shakespearolater");
+ }
+
+ public static readonly ShakespearolaterConverter Singleton = new ShakespearolaterConverter();
+ }
+
+ internal class AcademeConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Academe) || t == typeof(Academe?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Academe { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Academe { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Academe { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Academe");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Academe)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Academe");
+ }
+
+ public static readonly AcademeConverter Singleton = new AcademeConverter();
+ }
+
+ internal class AcquirableConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Acquirable) || t == typeof(Acquirable?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Acquirable { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Acquirable { UnionArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Acquirable");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Acquirable)untypedValue;
+ if (value.UnionArray != null)
+ {
+ serializer.Serialize(writer, value.UnionArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Acquirable");
+ }
+
+ public static readonly AcquirableConverter Singleton = new AcquirableConverter();
+ }
+
+ internal class AerometryConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Aerometry) || t == typeof(Aerometry?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Aerometry { Double = doubleValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Aerometry { Bool = boolValue };
+ }
+ throw new Exception("Cannot unmarshal type Aerometry");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Aerometry)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ throw new Exception("Cannot marshal type Aerometry");
+ }
+
+ public static readonly AerometryConverter Singleton = new AerometryConverter();
+ }
+
+ internal class AlexinConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Alexin) || t == typeof(Alexin?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Alexin { Bool = boolValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Alexin { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Alexin");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Alexin)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Alexin");
+ }
+
+ public static readonly AlexinConverter Singleton = new AlexinConverter();
+ }
+
+ internal class AlleviateElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(AlleviateElement) || t == typeof(AlleviateElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new AlleviateElement { AlleviateClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new AlleviateElement { UnionArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type AlleviateElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (AlleviateElement)untypedValue;
+ if (value.UnionArray != null)
+ {
+ serializer.Serialize(writer, value.UnionArray);
+ return;
+ }
+ if (value.AlleviateClass != null)
+ {
+ serializer.Serialize(writer, value.AlleviateClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type AlleviateElement");
+ }
+
+ public static readonly AlleviateElementConverter Singleton = new AlleviateElementConverter();
+ }
+
+ internal class AmaaConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Amaa) || t == typeof(Amaa?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Amaa { Integer = integerValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Amaa { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Amaa { Rebecca = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type Amaa");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Amaa)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.Rebecca != null)
+ {
+ serializer.Serialize(writer, value.Rebecca);
+ return;
+ }
+ throw new Exception("Cannot marshal type Amaa");
+ }
+
+ public static readonly AmaaConverter Singleton = new AmaaConverter();
+ }
+
+ internal class AmbassageConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Ambassage) || t == typeof(Ambassage?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Ambassage { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Ambassage { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Ambassage");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Ambassage)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Ambassage");
+ }
+
+ public static readonly AmbassageConverter Singleton = new AmbassageConverter();
+ }
+
+ internal class AnkeeElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(AnkeeElement) || t == typeof(AnkeeElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new AnkeeElement { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new AnkeeElement { AnkeeClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new AnkeeElement { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type AnkeeElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (AnkeeElement)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.AnkeeClass != null)
+ {
+ serializer.Serialize(writer, value.AnkeeClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type AnkeeElement");
+ }
+
+ public static readonly AnkeeElementConverter Singleton = new AnkeeElementConverter();
+ }
+
+ internal class AphasiaConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Aphasia) || t == typeof(Aphasia?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Aphasia { Integer = integerValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Aphasia { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Aphasia");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Aphasia)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Aphasia");
+ }
+
+ public static readonly AphasiaConverter Singleton = new AphasiaConverter();
+ }
+
+ internal class AsprawlConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Asprawl) || t == typeof(Asprawl?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Asprawl { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Asprawl { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Asprawl");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Asprawl)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Asprawl");
+ }
+
+ public static readonly AsprawlConverter Singleton = new AsprawlConverter();
+ }
+
+ internal class BedesmanConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Bedesman) || t == typeof(Bedesman?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Bedesman { Double = doubleValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Bedesman { Bool = boolValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Bedesman { String = stringValue };
+ }
+ throw new Exception("Cannot unmarshal type Bedesman");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Bedesman)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ throw new Exception("Cannot marshal type Bedesman");
+ }
+
+ public static readonly BedesmanConverter Singleton = new BedesmanConverter();
+ }
+
+ internal class BelardConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Belard) || t == typeof(Belard?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Belard { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Belard { Rebecca = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Belard { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Belard");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Belard)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.Rebecca != null)
+ {
+ serializer.Serialize(writer, value.Rebecca);
+ return;
+ }
+ throw new Exception("Cannot marshal type Belard");
+ }
+
+ public static readonly BelardConverter Singleton = new BelardConverter();
+ }
+
+ internal class BockingConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Bocking) || t == typeof(Bocking?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Bocking { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Bocking { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Bocking { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Bocking");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Bocking)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Bocking");
+ }
+
+ public static readonly BockingConverter Singleton = new BockingConverter();
+ }
+
+ internal class BrawlinglyConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Brawlingly) || t == typeof(Brawlingly?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Brawlingly { UnionMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Brawlingly { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Brawlingly");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Brawlingly)untypedValue;
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.UnionMap != null)
+ {
+ serializer.Serialize(writer, value.UnionMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Brawlingly");
+ }
+
+ public static readonly BrawlinglyConverter Singleton = new BrawlinglyConverter();
+ }
+
+ internal class BrookieConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Brookie) || t == typeof(Brookie?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new Brookie { Rebecca = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Brookie { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Brookie");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Brookie)untypedValue;
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.Rebecca != null)
+ {
+ serializer.Serialize(writer, value.Rebecca);
+ return;
+ }
+ throw new Exception("Cannot marshal type Brookie");
+ }
+
+ public static readonly BrookieConverter Singleton = new BrookieConverter();
+ }
+
+ internal class BumboatmanConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Bumboatman) || t == typeof(Bumboatman?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Bumboatman { };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Bumboatman { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Bumboatman { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Bumboatman");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Bumboatman)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Bumboatman");
+ }
+
+ public static readonly BumboatmanConverter Singleton = new BumboatmanConverter();
+ }
+
+ internal class CalaveriteConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Calaverite) || t == typeof(Calaverite?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Calaverite { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Calaverite { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Calaverite");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Calaverite)untypedValue;
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Calaverite");
+ }
+
+ public static readonly CalaveriteConverter Singleton = new CalaveriteConverter();
+ }
+
+ internal class CatallacticConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Catallactic) || t == typeof(Catallactic?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Catallactic { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Catallactic { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Catallactic { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Catallactic");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Catallactic)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Catallactic");
+ }
+
+ public static readonly CatallacticConverter Singleton = new CatallacticConverter();
+ }
+
+ internal class CementalConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Cemental) || t == typeof(Cemental?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Cemental { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Cemental { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Cemental { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Cemental");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Cemental)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Cemental");
+ }
+
+ public static readonly CementalConverter Singleton = new CementalConverter();
+ }
+}
+#pragma warning restore CS8618
+#pragma warning restore CS8601
+#pragma warning restore CS8602
+#pragma warning restore CS8603
+#pragma warning restore CS8604
+#pragma warning restore CS8625
+#pragma warning restore CS8765
diff --git a/head/csharp/test/inputs/json/priority/combinations3.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs b/head/csharp/test/inputs/json/priority/combinations3.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs
new file mode 100644
index 0000000..a969c50
--- /dev/null
+++ b/head/csharp/test/inputs/json/priority/combinations3.json/csharp-version-6__nullable-reference-types-true--15f50cfe6957/QuickType.cs
@@ -0,0 +1,2957 @@
+//
+//
+// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
+//
+// using QuickType;
+//
+// var topLevel = TopLevel.FromJson(jsonString);
+#nullable enable
+#pragma warning disable CS8618
+#pragma warning disable CS8601
+#pragma warning disable CS8602
+#pragma warning disable CS8603
+#pragma warning disable CS8604
+#pragma warning disable CS8625
+#pragma warning disable CS8765
+
+namespace QuickType
+{
+ using System;
+ using System.Collections.Generic;
+
+ using System.Globalization;
+ using Newtonsoft.Json;
+ using Newtonsoft.Json.Converters;
+
+ public partial class TopLevel
+ {
+ [JsonProperty("juror", Required = Required.Always)]
+ public JurorElement[] Juror { get; set; }
+
+ [JsonProperty("kongoni", Required = Required.Always)]
+ public Kongoni[] Kongoni { get; set; }
+
+ [JsonProperty("ladronism", Required = Required.Always)]
+ public LadronismElement[] Ladronism { get; set; }
+
+ [JsonProperty("landlubberly", Required = Required.Always)]
+ public LandlubberlyElement[] Landlubberly { get; set; }
+
+ [JsonProperty("listener", Required = Required.Always)]
+ public Listener[] Listener { get; set; }
+
+ [JsonProperty("lupus", Required = Required.Always)]
+ public LupusElement[] Lupus { get; set; }
+
+ [JsonProperty("maslin", Required = Required.Always)]
+ public Maslin[] Maslin { get; set; }
+
+ [JsonProperty("monazite", Required = Required.Always)]
+ public MonaziteElement[] Monazite { get; set; }
+
+ [JsonProperty("monoliteral", Required = Required.Always)]
+ public Monoliteral[] Monoliteral { get; set; }
+
+ [JsonProperty("monotheistically", Required = Required.Always)]
+ public MonotheisticallyElement[] Monotheistically { get; set; }
+
+ [JsonProperty("montage", Required = Required.Always)]
+ public Montage[] Montage { get; set; }
+
+ [JsonProperty("moralness", Required = Required.Always)]
+ public Moralness[] Moralness { get; set; }
+
+ [JsonProperty("mowra", Required = Required.Always)]
+ public MonaziteClass?[] Mowra { get; set; }
+
+ [JsonProperty("mulishly", Required = Required.Always)]
+ public Mulishly[] Mulishly { get; set; }
+
+ [JsonProperty("myoscope", Required = Required.Always)]
+ public Myoscope[] Myoscope { get; set; }
+
+ [JsonProperty("nach", Required = Required.Always)]
+ public long?[]?[] Nach { get; set; }
+
+ [JsonProperty("neuromastic", Required = Required.Always)]
+ public Neuromastic[] Neuromastic { get; set; }
+
+ [JsonProperty("noncontributing", Required = Required.Always)]
+ public Noncontributing[] Noncontributing { get; set; }
+
+ [JsonProperty("nonnervous", Required = Required.Always)]
+ public Nonnervous[] Nonnervous { get; set; }
+
+ [JsonProperty("nonvaluation", Required = Required.Always)]
+ public Nonvaluation[] Nonvaluation { get; set; }
+
+ [JsonProperty("occupationalist", Required = Required.Always)]
+ public OccupationalistElement[] Occupationalist { get; set; }
+
+ [JsonProperty("outrival", Required = Required.Always)]
+ public OutrivalElement[] Outrival { get; set; }
+
+ [JsonProperty("paleographically", Required = Required.Always)]
+ public Paleographically[] Paleographically { get; set; }
+
+ [JsonProperty("pamphletwise", Required = Required.Always)]
+ public Pamphletwise[] Pamphletwise { get; set; }
+
+ [JsonProperty("pediatrics", Required = Required.Always)]
+ public Pediatric[] Pediatrics { get; set; }
+
+ [JsonProperty("perceptive", Required = Required.Always)]
+ public bool[] Perceptive { get; set; }
+
+ [JsonProperty("piaculum", Required = Required.Always)]
+ public PiaculumElement[] Piaculum { get; set; }
+
+ [JsonProperty("piccadilly", Required = Required.Always)]
+ public Piccadilly[] Piccadilly { get; set; }
+
+ [JsonProperty("piffler", Required = Required.Always)]
+ public Piffler[] Piffler { get; set; }
+
+ [JsonProperty("pithful", Required = Required.Always)]
+ public Pithful[] Pithful { get; set; }
+
+ [JsonProperty("placuntitis", Required = Required.Always)]
+ public Placuntiti[] Placuntitis { get; set; }
+
+ [JsonProperty("plectopterous", Required = Required.Always)]
+ public Plectopterous[] Plectopterous { get; set; }
+
+ [JsonProperty("pneumocele", Required = Required.Always)]
+ public Pneumocele?[] Pneumocele { get; set; }
+
+ [JsonProperty("poliorcetic", Required = Required.Always)]
+ public Poliorcetic[] Poliorcetic { get; set; }
+
+ [JsonProperty("poormaster", Required = Required.Always)]
+ public Poormaster[] Poormaster { get; set; }
+
+ [JsonProperty("potwhisky", Required = Required.Always)]
+ public PotwhiskyElement[] Potwhisky { get; set; }
+
+ [JsonProperty("practicalizer", Required = Required.Always)]
+ public Practicalizer[] Practicalizer { get; set; }
+
+ [JsonProperty("prefreshman", Required = Required.Always)]
+ public PrefreshmanElement[] Prefreshman { get; set; }
+
+ [JsonProperty("prehensility", Required = Required.Always)]
+ public Prehensility[] Prehensility { get; set; }
+
+ [JsonProperty("prevoidance", Required = Required.Always)]
+ public Prevoidance[] Prevoidance { get; set; }
+
+ [JsonProperty("probant", Required = Required.Always)]
+ public Dictionary[] Probant { get; set; }
+
+ [JsonProperty("protext", Required = Required.Always)]
+ public Protext[] Protext { get; set; }
+ }
+
+ public partial class JurorClass
+ {
+ [JsonProperty("adipsy", Required = Required.AllowNull)]
+ public object Adipsy { get; set; }
+
+ [JsonProperty("auxiliator", Required = Required.AllowNull)]
+ public object Auxiliator { get; set; }
+
+ [JsonProperty("benda", Required = Required.AllowNull)]
+ public object Benda { get; set; }
+
+ [JsonProperty("benjamin", Required = Required.AllowNull)]
+ public object Benjamin { get; set; }
+
+ [JsonProperty("brandling", Required = Required.AllowNull)]
+ public object Brandling { get; set; }
+
+ [JsonProperty("epicurishly", Required = Required.AllowNull)]
+ public object Epicurishly { get; set; }
+
+ [JsonProperty("eremochaetous", Required = Required.AllowNull)]
+ public object Eremochaetous { get; set; }
+
+ [JsonProperty("marten", Required = Required.AllowNull)]
+ public object Marten { get; set; }
+
+ [JsonProperty("monocline", Required = Required.AllowNull)]
+ public object Monocline { get; set; }
+
+ [JsonProperty("Olea", Required = Required.AllowNull)]
+ public object Olea { get; set; }
+
+ [JsonProperty("palgat", Required = Required.AllowNull)]
+ public object Palgat { get; set; }
+
+ [JsonProperty("pennyworth", Required = Required.AllowNull)]
+ public object Pennyworth { get; set; }
+
+ [JsonProperty("pioury", Required = Required.AllowNull)]
+ public object Pioury { get; set; }
+
+ [JsonProperty("pragmatistic", Required = Required.AllowNull)]
+ public object Pragmatistic { get; set; }
+
+ [JsonProperty("stylelessness", Required = Required.AllowNull)]
+ public object Stylelessness { get; set; }
+
+ [JsonProperty("systematical", Required = Required.AllowNull)]
+ public object Systematical { get; set; }
+
+ [JsonProperty("thready", Required = Required.AllowNull)]
+ public object Thready { get; set; }
+
+ [JsonProperty("uncontemporary", Required = Required.AllowNull)]
+ public object Uncontemporary { get; set; }
+
+ [JsonProperty("uncouched", Required = Required.AllowNull)]
+ public object Uncouched { get; set; }
+
+ [JsonProperty("uninhabitedness", Required = Required.AllowNull)]
+ public object Uninhabitedness { get; set; }
+ }
+
+ public partial class LadronismClass
+ {
+ [JsonProperty("acclaimer", Required = Required.AllowNull)]
+ public object Acclaimer { get; set; }
+
+ [JsonProperty("achree", Required = Required.AllowNull)]
+ public object Achree { get; set; }
+
+ [JsonProperty("base", Required = Required.AllowNull)]
+ public object Base { get; set; }
+
+ [JsonProperty("conundrumize", Required = Required.AllowNull)]
+ public object Conundrumize { get; set; }
+
+ [JsonProperty("degerminator", Required = Required.AllowNull)]
+ public object Degerminator { get; set; }
+
+ [JsonProperty("describable", Required = Required.AllowNull)]
+ public object Describable { get; set; }
+
+ [JsonProperty("exasperatedly", Required = Required.AllowNull)]
+ public object Exasperatedly { get; set; }
+
+ [JsonProperty("heroine", Required = Required.AllowNull)]
+ public object Heroine { get; set; }
+
+ [JsonProperty("indazin", Required = Required.AllowNull)]
+ public object Indazin { get; set; }
+
+ [JsonProperty("luteous", Required = Required.AllowNull)]
+ public object Luteous { get; set; }
+
+ [JsonProperty("papular", Required = Required.AllowNull)]
+ public object Papular { get; set; }
+
+ [JsonProperty("pritch", Required = Required.AllowNull)]
+ public object Pritch { get; set; }
+
+ [JsonProperty("Prodenia", Required = Required.AllowNull)]
+ public object Prodenia { get; set; }
+
+ [JsonProperty("seege", Required = Required.AllowNull)]
+ public object Seege { get; set; }
+
+ [JsonProperty("shopgirl", Required = Required.AllowNull)]
+ public object Shopgirl { get; set; }
+
+ [JsonProperty("tragedietta", Required = Required.AllowNull)]
+ public object Tragedietta { get; set; }
+
+ [JsonProperty("unsparse", Required = Required.AllowNull)]
+ public object Unsparse { get; set; }
+
+ [JsonProperty("uplook", Required = Required.AllowNull)]
+ public object Uplook { get; set; }
+
+ [JsonProperty("vermiformis", Required = Required.AllowNull)]
+ public object Vermiformis { get; set; }
+
+ [JsonProperty("whafabout", Required = Required.AllowNull)]
+ public object Whafabout { get; set; }
+ }
+
+ public partial class LandlubberlyClass
+ {
+ [JsonProperty("acropoleis", Required = Required.AllowNull)]
+ public object Acropoleis { get; set; }
+
+ [JsonProperty("aminate", Required = Required.AllowNull)]
+ public object Aminate { get; set; }
+
+ [JsonProperty("Amyraldism", Required = Required.AllowNull)]
+ public object Amyraldism { get; set; }
+
+ [JsonProperty("bipenniform", Required = Required.AllowNull)]
+ public object Bipenniform { get; set; }
+
+ [JsonProperty("bugre", Required = Required.AllowNull)]
+ public object Bugre { get; set; }
+
+ [JsonProperty("calycule", Required = Required.AllowNull)]
+ public object Calycule { get; set; }
+
+ [JsonProperty("caoutchouc", Required = Required.AllowNull)]
+ public object Caoutchouc { get; set; }
+
+ [JsonProperty("disprover", Required = Required.AllowNull)]
+ public object Disprover { get; set; }
+
+ [JsonProperty("fitroot", Required = Required.AllowNull)]
+ public object Fitroot { get; set; }
+
+ [JsonProperty("fulgently", Required = Required.AllowNull)]
+ public object Fulgently { get; set; }
+
+ [JsonProperty("kickup", Required = Required.AllowNull)]
+ public object Kickup { get; set; }
+
+ [JsonProperty("laevoversion", Required = Required.AllowNull)]
+ public object Laevoversion { get; set; }
+
+ [JsonProperty("moter", Required = Required.AllowNull)]
+ public object Moter { get; set; }
+
+ [JsonProperty("objectivity", Required = Required.AllowNull)]
+ public object Objectivity { get; set; }
+
+ [JsonProperty("posterity", Required = Required.AllowNull)]
+ public object Posterity { get; set; }
+
+ [JsonProperty("postnuptial", Required = Required.AllowNull)]
+ public object Postnuptial { get; set; }
+
+ [JsonProperty("precedentary", Required = Required.AllowNull)]
+ public object Precedentary { get; set; }
+
+ [JsonProperty("saddling", Required = Required.AllowNull)]
+ public object Saddling { get; set; }
+
+ [JsonProperty("subcurrent", Required = Required.AllowNull)]
+ public object Subcurrent { get; set; }
+
+ [JsonProperty("unrecriminative", Required = Required.AllowNull)]
+ public object Unrecriminative { get; set; }
+ }
+
+ public partial class LupusClass
+ {
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("Chlorioninae", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chlorioninae { get; set; }
+
+ [JsonProperty("Corvinae", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Corvinae { get; set; }
+
+ [JsonProperty("Crassina", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Crassina { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("exiguity", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Exiguity { get; set; }
+
+ [JsonProperty("farcist", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Farcist { get; set; }
+
+ [JsonProperty("holographical", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Holographical { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("ichthyophagan", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Ichthyophagan { get; set; }
+
+ [JsonProperty("implacable", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Implacable { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("outshiner", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Outshiner { get; set; }
+
+ [JsonProperty("overweather", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Overweather { get; set; }
+
+ [JsonProperty("protonegroid", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Protonegroid { get; set; }
+
+ [JsonProperty("shallowish", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Shallowish { get; set; }
+
+ [JsonProperty("snoke", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Snoke { get; set; }
+
+ [JsonProperty("snout", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Snout { get; set; }
+
+ [JsonProperty("surveillance", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Surveillance { get; set; }
+
+ [JsonProperty("threshingtime", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Threshingtime { get; set; }
+
+ [JsonProperty("Thysanocarpus", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Thysanocarpus { get; set; }
+
+ [JsonProperty("unsignificantly", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Unsignificantly { get; set; }
+
+ [JsonProperty("unsnap", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Unsnap { get; set; }
+
+ [JsonProperty("vendible", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Vendible { get; set; }
+ }
+
+ public partial class Maslin
+ {
+ [JsonProperty("Alicant", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Alicant { get; set; }
+
+ [JsonProperty("antiatonement")]
+ public object? Antiatonement { get; set; }
+
+ [JsonProperty("anticorrosive", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Anticorrosive { get; set; }
+
+ [JsonProperty("aphidozer")]
+ public object? Aphidozer { get; set; }
+
+ [JsonProperty("Bakuninist")]
+ public object? Bakuninist { get; set; }
+
+ [JsonProperty("be", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Be { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("chub", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chub { get; set; }
+
+ [JsonProperty("cuprosilicon", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Cuprosilicon { get; set; }
+
+ [JsonProperty("curtailedly", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Curtailedly { get; set; }
+
+ [JsonProperty("dellenite", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Dellenite { get; set; }
+
+ [JsonProperty("Dimitry", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Dimitry { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("edifying")]
+ public object? Edifying { get; set; }
+
+ [JsonProperty("ethmoiditis", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Ethmoiditis { get; set; }
+
+ [JsonProperty("gastralgy")]
+ public object? Gastralgy { get; set; }
+
+ [JsonProperty("goatherd", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Goatherd { get; set; }
+
+ [JsonProperty("hammerdress", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Hammerdress { get; set; }
+
+ [JsonProperty("hangfire")]
+ public object? Hangfire { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("lacunosity", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Lacunosity { get; set; }
+
+ [JsonProperty("longiloquence")]
+ public object? Longiloquence { get; set; }
+
+ [JsonProperty("mameliere", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Mameliere { get; set; }
+
+ [JsonProperty("motherless")]
+ public object? Motherless { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("noncorrodible")]
+ public object? Noncorrodible { get; set; }
+
+ [JsonProperty("nonsensicality")]
+ public object? Nonsensicality { get; set; }
+
+ [JsonProperty("oafishly", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Oafishly { get; set; }
+
+ [JsonProperty("pfund")]
+ public object? Pfund { get; set; }
+
+ [JsonProperty("preadvisory")]
+ public object? Preadvisory { get; set; }
+
+ [JsonProperty("retroflexed")]
+ public object? Retroflexed { get; set; }
+
+ [JsonProperty("saccharulmic", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Saccharulmic { get; set; }
+
+ [JsonProperty("scowlful", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Scowlful { get; set; }
+
+ [JsonProperty("secluded")]
+ public object? Secluded { get; set; }
+
+ [JsonProperty("slackage")]
+ public object? Slackage { get; set; }
+
+ [JsonProperty("sphaeridial", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Sphaeridial { get; set; }
+
+ [JsonProperty("spondulics")]
+ public object? Spondulics { get; set; }
+
+ [JsonProperty("subsecive", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Subsecive { get; set; }
+
+ [JsonProperty("swellmobsman")]
+ public object? Swellmobsman { get; set; }
+
+ [JsonProperty("trachyglossate", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Trachyglossate { get; set; }
+
+ [JsonProperty("trialogue")]
+ public object? Trialogue { get; set; }
+
+ [JsonProperty("unassuaged", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Unassuaged { get; set; }
+
+ [JsonProperty("ungross")]
+ public object? Ungross { get; set; }
+
+ [JsonProperty("unjudiciously")]
+ public object? Unjudiciously { get; set; }
+ }
+
+ public partial class MonaziteClass
+ {
+ [JsonProperty("catharticalness", Required = Required.Always)]
+ public double Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", Required = Required.Always)]
+ public long Chirotherium { get; set; }
+
+ [JsonProperty("disdiapason", Required = Required.Always)]
+ public string Disdiapason { get; set; }
+
+ [JsonProperty("homocerc", Required = Required.Always)]
+ public bool Homocerc { get; set; }
+
+ [JsonProperty("nonbookish", Required = Required.AllowNull)]
+ public object Nonbookish { get; set; }
+ }
+
+ public partial class MonotheisticallyClass
+ {
+ [JsonProperty("blaspheme")]
+ public object? Blaspheme { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("celiosalpingectomy")]
+ public object? Celiosalpingectomy { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("consummativeness")]
+ public object? Consummativeness { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("egestive")]
+ public object? Egestive { get; set; }
+
+ [JsonProperty("enchylema")]
+ public object? Enchylema { get; set; }
+
+ [JsonProperty("gasconade")]
+ public object? Gasconade { get; set; }
+
+ [JsonProperty("holidayer")]
+ public object? Holidayer { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("intuitionalism")]
+ public object? Intuitionalism { get; set; }
+
+ [JsonProperty("lophiostomate")]
+ public object? Lophiostomate { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("nonvolition")]
+ public object? Nonvolition { get; set; }
+
+ [JsonProperty("palatableness")]
+ public object? Palatableness { get; set; }
+
+ [JsonProperty("pimpery")]
+ public object? Pimpery { get; set; }
+
+ [JsonProperty("previolation")]
+ public object? Previolation { get; set; }
+
+ [JsonProperty("reconveyance")]
+ public object? Reconveyance { get; set; }
+
+ [JsonProperty("registership")]
+ public object? Registership { get; set; }
+
+ [JsonProperty("rhyacolite")]
+ public object? Rhyacolite { get; set; }
+
+ [JsonProperty("smithereens")]
+ public object? Smithereens { get; set; }
+
+ [JsonProperty("superedification")]
+ public object? Superedification { get; set; }
+
+ [JsonProperty("trust")]
+ public object? Trust { get; set; }
+
+ [JsonProperty("whitestone")]
+ public object? Whitestone { get; set; }
+ }
+
+ public partial class Noncontributing
+ {
+ [JsonProperty("estevin", Required = Required.Always)]
+ public string Estevin { get; set; }
+
+ [JsonProperty("jolterhead", Required = Required.Always)]
+ public double Jolterhead { get; set; }
+
+ [JsonProperty("sauternes", Required = Required.Always)]
+ public long Sauternes { get; set; }
+
+ [JsonProperty("sparsely", Required = Required.Always)]
+ public bool Sparsely { get; set; }
+
+ [JsonProperty("unrequested", Required = Required.AllowNull)]
+ public object Unrequested { get; set; }
+ }
+
+ public partial class OccupationalistClass
+ {
+ [JsonProperty("beholdable", Required = Required.AllowNull)]
+ public object Beholdable { get; set; }
+
+ [JsonProperty("brotuliform", Required = Required.AllowNull)]
+ public object Brotuliform { get; set; }
+
+ [JsonProperty("Chimakum", Required = Required.AllowNull)]
+ public object Chimakum { get; set; }
+
+ [JsonProperty("doodler", Required = Required.AllowNull)]
+ public object Doodler { get; set; }
+
+ [JsonProperty("emulsin", Required = Required.AllowNull)]
+ public object Emulsin { get; set; }
+
+ [JsonProperty("Fin", Required = Required.AllowNull)]
+ public object Fin { get; set; }
+
+ [JsonProperty("flourishing", Required = Required.AllowNull)]
+ public object Flourishing { get; set; }
+
+ [JsonProperty("flueless", Required = Required.AllowNull)]
+ public object Flueless { get; set; }
+
+ [JsonProperty("furtively", Required = Required.AllowNull)]
+ public object Furtively { get; set; }
+
+ [JsonProperty("gritter", Required = Required.AllowNull)]
+ public object Gritter { get; set; }
+
+ [JsonProperty("interwish", Required = Required.AllowNull)]
+ public object Interwish { get; set; }
+
+ [JsonProperty("monoxylic", Required = Required.AllowNull)]
+ public object Monoxylic { get; set; }
+
+ [JsonProperty("myristic", Required = Required.AllowNull)]
+ public object Myristic { get; set; }
+
+ [JsonProperty("nightwear", Required = Required.AllowNull)]
+ public object Nightwear { get; set; }
+
+ [JsonProperty("peruser", Required = Required.AllowNull)]
+ public object Peruser { get; set; }
+
+ [JsonProperty("theoastrological", Required = Required.AllowNull)]
+ public object Theoastrological { get; set; }
+
+ [JsonProperty("thumby", Required = Required.AllowNull)]
+ public object Thumby { get; set; }
+
+ [JsonProperty("tingitid", Required = Required.AllowNull)]
+ public object Tingitid { get; set; }
+
+ [JsonProperty("trailless", Required = Required.AllowNull)]
+ public object Trailless { get; set; }
+
+ [JsonProperty("unpocketed", Required = Required.AllowNull)]
+ public object Unpocketed { get; set; }
+ }
+
+ public partial class OutrivalClass
+ {
+ [JsonProperty("adroitly", Required = Required.AllowNull)]
+ public object Adroitly { get; set; }
+
+ [JsonProperty("bridehood", Required = Required.AllowNull)]
+ public object Bridehood { get; set; }
+
+ [JsonProperty("Castoroides", Required = Required.AllowNull)]
+ public object Castoroides { get; set; }
+
+ [JsonProperty("Czechoslovak", Required = Required.AllowNull)]
+ public object Czechoslovak { get; set; }
+
+ [JsonProperty("diagenesis", Required = Required.AllowNull)]
+ public object Diagenesis { get; set; }
+
+ [JsonProperty("dihexahedron", Required = Required.AllowNull)]
+ public object Dihexahedron { get; set; }
+
+ [JsonProperty("dopester", Required = Required.AllowNull)]
+ public object Dopester { get; set; }
+
+ [JsonProperty("eumerism", Required = Required.AllowNull)]
+ public object Eumerism { get; set; }
+
+ [JsonProperty("flyness", Required = Required.AllowNull)]
+ public object Flyness { get; set; }
+
+ [JsonProperty("fouler", Required = Required.AllowNull)]
+ public object Fouler { get; set; }
+
+ [JsonProperty("laudanosine", Required = Required.AllowNull)]
+ public object Laudanosine { get; set; }
+
+ [JsonProperty("Lingulidae", Required = Required.AllowNull)]
+ public object Lingulidae { get; set; }
+
+ [JsonProperty("minutary", Required = Required.AllowNull)]
+ public object Minutary { get; set; }
+
+ [JsonProperty("mitra", Required = Required.AllowNull)]
+ public object Mitra { get; set; }
+
+ [JsonProperty("opisthorchiasis", Required = Required.AllowNull)]
+ public object Opisthorchiasis { get; set; }
+
+ [JsonProperty("pensively", Required = Required.AllowNull)]
+ public object Pensively { get; set; }
+
+ [JsonProperty("pubigerous", Required = Required.AllowNull)]
+ public object Pubigerous { get; set; }
+
+ [JsonProperty("rebellious", Required = Required.AllowNull)]
+ public object Rebellious { get; set; }
+
+ [JsonProperty("recodify", Required = Required.AllowNull)]
+ public object Recodify { get; set; }
+
+ [JsonProperty("unpaced", Required = Required.AllowNull)]
+ public object Unpaced { get; set; }
+ }
+
+ public partial class PiaculumClass
+ {
+ [JsonProperty("alada", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Alada { get; set; }
+
+ [JsonProperty("amphistomous", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Amphistomous { get; set; }
+
+ [JsonProperty("boysenberry", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Boysenberry { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("decardinalize", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Decardinalize { get; set; }
+
+ [JsonProperty("discouragement", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Discouragement { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("doitrified", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Doitrified { get; set; }
+
+ [JsonProperty("hexaspermous", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Hexaspermous { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("insinking", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Insinking { get; set; }
+
+ [JsonProperty("loathfulness", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Loathfulness { get; set; }
+
+ [JsonProperty("miasmatical", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Miasmatical { get; set; }
+
+ [JsonProperty("neurofibril", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Neurofibril { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("phonendoscope", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Phonendoscope { get; set; }
+
+ [JsonProperty("pilferment", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Pilferment { get; set; }
+
+ [JsonProperty("predismissory", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Predismissory { get; set; }
+
+ [JsonProperty("preinscription", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Preinscription { get; set; }
+
+ [JsonProperty("quotative", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Quotative { get; set; }
+
+ [JsonProperty("sienna", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Sienna { get; set; }
+
+ [JsonProperty("thorax", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Thorax { get; set; }
+
+ [JsonProperty("yachting", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Yachting { get; set; }
+
+ [JsonProperty("Zipper", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Zipper { get; set; }
+ }
+
+ public partial class Pneumocele
+ {
+ [JsonProperty("Carbonarism")]
+ public object? Carbonarism { get; set; }
+
+ [JsonProperty("catharticalness", NullValueHandling = NullValueHandling.Ignore)]
+ public double? Catharticalness { get; set; }
+
+ [JsonProperty("Chirotherium", NullValueHandling = NullValueHandling.Ignore)]
+ public long? Chirotherium { get; set; }
+
+ [JsonProperty("cineolic")]
+ public object? Cineolic { get; set; }
+
+ [JsonProperty("cobbly")]
+ public object? Cobbly { get; set; }
+
+ [JsonProperty("conchyliferous")]
+ public object? Conchyliferous { get; set; }
+
+ [JsonProperty("congregation")]
+ public object? Congregation { get; set; }
+
+ [JsonProperty("disdiapason", NullValueHandling = NullValueHandling.Ignore)]
+ public string? Disdiapason { get; set; }
+
+ [JsonProperty("enterotomy")]
+ public object? Enterotomy { get; set; }
+
+ [JsonProperty("entophytal")]
+ public object? Entophytal { get; set; }
+
+ [JsonProperty("fewtrils")]
+ public object? Fewtrils { get; set; }
+
+ [JsonProperty("herem")]
+ public object? Herem { get; set; }
+
+ [JsonProperty("homocerc", NullValueHandling = NullValueHandling.Ignore)]
+ public bool? Homocerc { get; set; }
+
+ [JsonProperty("Koniga")]
+ public object? Koniga { get; set; }
+
+ [JsonProperty("meticulosity")]
+ public object? Meticulosity { get; set; }
+
+ [JsonProperty("Micky")]
+ public object? Micky { get; set; }
+
+ [JsonProperty("mismarriage")]
+ public object? Mismarriage { get; set; }
+
+ [JsonProperty("neurotrophic")]
+ public object? Neurotrophic { get; set; }
+
+ [JsonProperty("nonbookish")]
+ public object? Nonbookish { get; set; }
+
+ [JsonProperty("persuasively")]
+ public object? Persuasively { get; set; }
+
+ [JsonProperty("replaceable")]
+ public object? Replaceable { get; set; }
+
+ [JsonProperty("silex")]
+ public object? Silex { get; set; }
+
+ [JsonProperty("taillight")]
+ public object? Taillight { get; set; }
+
+ [JsonProperty("unjealous")]
+ public object? Unjealous { get; set; }
+
+ [JsonProperty("visitorial")]
+ public object? Visitorial { get; set; }
+ }
+
+ public partial class PotwhiskyClass
+ {
+ [JsonProperty("arciform", Required = Required.AllowNull)]
+ public object Arciform { get; set; }
+
+ [JsonProperty("cresolin", Required = Required.AllowNull)]
+ public object Cresolin { get; set; }
+
+ [JsonProperty("disheartener", Required = Required.AllowNull)]
+ public object Disheartener { get; set; }
+
+ [JsonProperty("disproportionable", Required = Required.AllowNull)]
+ public object Disproportionable { get; set; }
+
+ [JsonProperty("Euchorda", Required = Required.AllowNull)]
+ public object Euchorda { get; set; }
+
+ [JsonProperty("ferryway", Required = Required.AllowNull)]
+ public object Ferryway { get; set; }
+
+ [JsonProperty("filamentiferous", Required = Required.AllowNull)]
+ public object Filamentiferous { get; set; }
+
+ [JsonProperty("flemish", Required = Required.AllowNull)]
+ public object Flemish { get; set; }
+
+ [JsonProperty("forgainst", Required = Required.AllowNull)]
+ public object Forgainst { get; set; }
+
+ [JsonProperty("grainering", Required = Required.AllowNull)]
+ public object Grainering { get; set; }
+
+ [JsonProperty("irrevoluble", Required = Required.AllowNull)]
+ public object Irrevoluble { get; set; }
+
+ [JsonProperty("kindredship", Required = Required.AllowNull)]
+ public object Kindredship { get; set; }
+
+ [JsonProperty("pinguitudinous", Required = Required.AllowNull)]
+ public object Pinguitudinous { get; set; }
+
+ [JsonProperty("simpletonic", Required = Required.AllowNull)]
+ public object Simpletonic { get; set; }
+
+ [JsonProperty("singsong", Required = Required.AllowNull)]
+ public object Singsong { get; set; }
+
+ [JsonProperty("submergement", Required = Required.AllowNull)]
+ public object Submergement { get; set; }
+
+ [JsonProperty("supraoesophagal", Required = Required.AllowNull)]
+ public object Supraoesophagal { get; set; }
+
+ [JsonProperty("thrashel", Required = Required.AllowNull)]
+ public object Thrashel { get; set; }
+
+ [JsonProperty("tyremesis", Required = Required.AllowNull)]
+ public object Tyremesis { get; set; }
+
+ [JsonProperty("Yoruba", Required = Required.AllowNull)]
+ public object Yoruba { get; set; }
+ }
+
+ public partial class PrefreshmanClass
+ {
+ [JsonProperty("azorubine", Required = Required.AllowNull)]
+ public object Azorubine { get; set; }
+
+ [JsonProperty("choroiditis", Required = Required.AllowNull)]
+ public object Choroiditis { get; set; }
+
+ [JsonProperty("coagulatory", Required = Required.AllowNull)]
+ public object Coagulatory { get; set; }
+
+ [JsonProperty("cyclorama", Required = Required.AllowNull)]
+ public object Cyclorama { get; set; }
+
+ [JsonProperty("Dolphus", Required = Required.AllowNull)]
+ public object Dolphus { get; set; }
+
+ [JsonProperty("duckhearted", Required = Required.AllowNull)]
+ public object Duckhearted { get; set; }
+
+ [JsonProperty("Ficus", Required = Required.AllowNull)]
+ public object Ficus { get; set; }
+
+ [JsonProperty("Gemaric", Required = Required.AllowNull)]
+ public object Gemaric { get; set; }
+
+ [JsonProperty("jugation", Required = Required.AllowNull)]
+ public object Jugation { get; set; }
+
+ [JsonProperty("myoliposis", Required = Required.AllowNull)]
+ public object Myoliposis { get; set; }
+
+ [JsonProperty("nonnomination", Required = Required.AllowNull)]
+ public object Nonnomination { get; set; }
+
+ [JsonProperty("palay", Required = Required.AllowNull)]
+ public object Palay { get; set; }
+
+ [JsonProperty("pentactinal", Required = Required.AllowNull)]
+ public object Pentactinal { get; set; }
+
+ [JsonProperty("Phaet", Required = Required.AllowNull)]
+ public object Phaet { get; set; }
+
+ [JsonProperty("piquant", Required = Required.AllowNull)]
+ public object Piquant { get; set; }
+
+ [JsonProperty("registration", Required = Required.AllowNull)]
+ public object Registration { get; set; }
+
+ [JsonProperty("remancipation", Required = Required.AllowNull)]
+ public object Remancipation { get; set; }
+
+ [JsonProperty("scutatiform", Required = Required.AllowNull)]
+ public object Scutatiform { get; set; }
+
+ [JsonProperty("theodolite", Required = Required.AllowNull)]
+ public object Theodolite { get; set; }
+
+ [JsonProperty("underward", Required = Required.AllowNull)]
+ public object Underward { get; set; }
+ }
+
+ public partial struct JurorElement
+ {
+ public bool? Bool;
+ public JurorClass? JurorClass;
+
+ public static implicit operator JurorElement(bool Bool) => new JurorElement { Bool = Bool };
+ public static implicit operator JurorElement(JurorClass JurorClass) => new JurorElement { JurorClass = JurorClass };
+ }
+
+ public partial struct Kongoni
+ {
+ public long[]? IntegerArray;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Kongoni(long[] IntegerArray) => new Kongoni { IntegerArray = IntegerArray };
+ public static implicit operator Kongoni(Dictionary IntegerMap) => new Kongoni { IntegerMap = IntegerMap };
+ }
+
+ public partial struct LadronismElement
+ {
+ public double? Double;
+ public LadronismClass? LadronismClass;
+ public string? String;
+
+ public static implicit operator LadronismElement(double Double) => new LadronismElement { Double = Double };
+ public static implicit operator LadronismElement(LadronismClass LadronismClass) => new LadronismElement { LadronismClass = LadronismClass };
+ public static implicit operator LadronismElement(string String) => new LadronismElement { String = String };
+ }
+
+ public partial struct LandlubberlyElement
+ {
+ public bool? Bool;
+ public long? Integer;
+ public LandlubberlyClass? LandlubberlyClass;
+
+ public static implicit operator LandlubberlyElement(bool Bool) => new LandlubberlyElement { Bool = Bool };
+ public static implicit operator LandlubberlyElement(long Integer) => new LandlubberlyElement { Integer = Integer };
+ public static implicit operator LandlubberlyElement(LandlubberlyClass LandlubberlyClass) => new LandlubberlyElement { LandlubberlyClass = LandlubberlyClass };
+ }
+
+ public partial struct Listener
+ {
+ public long? Integer;
+ public object[]? NullArray;
+
+ public static implicit operator Listener(long Integer) => new Listener { Integer = Integer };
+ public static implicit operator Listener(object[] NullArray) => new Listener { NullArray = NullArray };
+ }
+
+ public partial struct LupusElement
+ {
+ public long? Integer;
+ public LupusClass? LupusClass;
+
+ public static implicit operator LupusElement(long Integer) => new LupusElement { Integer = Integer };
+ public static implicit operator LupusElement(LupusClass LupusClass) => new LupusElement { LupusClass = LupusClass };
+ }
+
+ public partial struct MonaziteElement
+ {
+ public double? Double;
+ public MonaziteClass? MonaziteClass;
+
+ public static implicit operator MonaziteElement(double Double) => new MonaziteElement { Double = Double };
+ public static implicit operator MonaziteElement(MonaziteClass MonaziteClass) => new MonaziteElement { MonaziteClass = MonaziteClass };
+ }
+
+ public partial struct Monoliteral
+ {
+ public bool? Bool;
+ public object[]? NullArray;
+
+ public static implicit operator Monoliteral(bool Bool) => new Monoliteral { Bool = Bool };
+ public static implicit operator Monoliteral(object[] NullArray) => new Monoliteral { NullArray = NullArray };
+ }
+
+ public partial struct MonotheisticallyElement
+ {
+ public MonotheisticallyClass? MonotheisticallyClass;
+ public object[]? NullArray;
+
+ public static implicit operator MonotheisticallyElement(MonotheisticallyClass MonotheisticallyClass) => new MonotheisticallyElement { MonotheisticallyClass = MonotheisticallyClass };
+ public static implicit operator MonotheisticallyElement(object[] NullArray) => new MonotheisticallyElement { NullArray = NullArray };
+ }
+
+ public partial struct Montage
+ {
+ public double? Double;
+ public object[]? NullArray;
+ public string? String;
+
+ public static implicit operator Montage(double Double) => new Montage { Double = Double };
+ public static implicit operator Montage(object[] NullArray) => new Montage { NullArray = NullArray };
+ public static implicit operator Montage(string String) => new Montage { String = String };
+ }
+
+ public partial struct Moralness
+ {
+ public double? Double;
+ public object[]? NullArray;
+
+ public static implicit operator Moralness(double Double) => new Moralness { Double = Double };
+ public static implicit operator Moralness(object[] NullArray) => new Moralness { NullArray = NullArray };
+ public bool IsNull => NullArray == null && Double == null;
+ }
+
+ public partial struct Mulishly
+ {
+ public double? Double;
+ public long[]? IntegerArray;
+
+ public static implicit operator Mulishly(double Double) => new Mulishly { Double = Double };
+ public static implicit operator Mulishly(long[] IntegerArray) => new Mulishly { IntegerArray = IntegerArray };
+ public bool IsNull => IntegerArray == null && Double == null;
+ }
+
+ public partial struct Myoscope
+ {
+ public bool? Bool;
+ public long? Integer;
+ public object[]? NullArray;
+
+ public static implicit operator Myoscope(bool Bool) => new Myoscope { Bool = Bool };
+ public static implicit operator Myoscope(long Integer) => new Myoscope { Integer = Integer };
+ public static implicit operator Myoscope(object[] NullArray) => new Myoscope { NullArray = NullArray };
+ }
+
+ public partial struct Neuromastic
+ {
+ public double? Double;
+ public object[]? NullArray;
+
+ public static implicit operator Neuromastic(double Double) => new Neuromastic { Double = Double };
+ public static implicit operator Neuromastic(object[] NullArray) => new Neuromastic { NullArray = NullArray };
+ }
+
+ public partial struct Nonnervous
+ {
+ public bool? Bool;
+ public long? Integer;
+
+ public static implicit operator Nonnervous(bool Bool) => new Nonnervous { Bool = Bool };
+ public static implicit operator Nonnervous(long Integer) => new Nonnervous { Integer = Integer };
+ }
+
+ public partial struct Nonvaluation
+ {
+ public bool? Bool;
+ public double? Double;
+ public object[]? NullArray;
+
+ public static implicit operator Nonvaluation(bool Bool) => new Nonvaluation { Bool = Bool };
+ public static implicit operator Nonvaluation(double Double) => new Nonvaluation { Double = Double };
+ public static implicit operator Nonvaluation(object[] NullArray) => new Nonvaluation { NullArray = NullArray };
+ }
+
+ public partial struct OccupationalistElement
+ {
+ public object[]? NullArray;
+ public OccupationalistClass? OccupationalistClass;
+
+ public static implicit operator OccupationalistElement(object[] NullArray) => new OccupationalistElement { NullArray = NullArray };
+ public static implicit operator OccupationalistElement(OccupationalistClass OccupationalistClass) => new OccupationalistElement { OccupationalistClass = OccupationalistClass };
+ public bool IsNull => NullArray == null && OccupationalistClass == null;
+ }
+
+ public partial struct OutrivalElement
+ {
+ public double? Double;
+ public OutrivalClass? OutrivalClass;
+
+ public static implicit operator OutrivalElement(double Double) => new OutrivalElement { Double = Double };
+ public static implicit operator OutrivalElement(OutrivalClass OutrivalClass) => new OutrivalElement { OutrivalClass = OutrivalClass };
+ public bool IsNull => OutrivalClass == null && Double == null;
+ }
+
+ public partial struct Paleographically
+ {
+ public double? Double;
+ public Dictionary? UnionMap;
+
+ public static implicit operator Paleographically(double Double) => new Paleographically { Double = Double };
+ public static implicit operator Paleographically(Dictionary UnionMap) => new Paleographically { UnionMap = UnionMap };
+ }
+
+ public partial struct Pamphletwise
+ {
+ public long? Integer;
+ public Dictionary? IntegerMap;
+ public string? String;
+
+ public static implicit operator Pamphletwise(long Integer) => new Pamphletwise { Integer = Integer };
+ public static implicit operator Pamphletwise(Dictionary IntegerMap) => new Pamphletwise { IntegerMap = IntegerMap };
+ public static implicit operator Pamphletwise(string String) => new Pamphletwise { String = String };
+ }
+
+ public partial struct Pediatric
+ {
+ public bool? Bool;
+ public double? Double;
+
+ public static implicit operator Pediatric(bool Bool) => new Pediatric { Bool = Bool };
+ public static implicit operator Pediatric(double Double) => new Pediatric { Double = Double };
+ public bool IsNull => Bool == null && Double == null;
+ }
+
+ public partial struct PiaculumElement
+ {
+ public double? Double;
+ public PiaculumClass? PiaculumClass;
+
+ public static implicit operator PiaculumElement(double Double) => new PiaculumElement { Double = Double };
+ public static implicit operator PiaculumElement(PiaculumClass PiaculumClass) => new PiaculumElement { PiaculumClass = PiaculumClass };
+ }
+
+ public partial struct Piccadilly
+ {
+ public double? Double;
+ public string? String;
+
+ public static implicit operator Piccadilly(double Double) => new Piccadilly { Double = Double };
+ public static implicit operator Piccadilly(string String) => new Piccadilly { String = String };
+ public bool IsNull => Double == null && String == null;
+ }
+
+ public partial struct Piffler
+ {
+ public MonaziteClass? MonaziteClass;
+ public object[]? NullArray;
+
+ public static implicit operator Piffler(MonaziteClass MonaziteClass) => new Piffler { MonaziteClass = MonaziteClass };
+ public static implicit operator Piffler(object[] NullArray) => new Piffler { NullArray = NullArray };
+ }
+
+ public partial struct Pithful
+ {
+ public bool? Bool;
+ public long? Integer;
+
+ public static implicit operator Pithful(bool Bool) => new Pithful { Bool = Bool };
+ public static implicit operator Pithful(long Integer) => new Pithful { Integer = Integer };
+ public bool IsNull => Bool == null && Integer == null;
+ }
+
+ public partial struct Placuntiti
+ {
+ public long? Integer;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Placuntiti(long Integer) => new Placuntiti { Integer = Integer };
+ public static implicit operator Placuntiti(Dictionary IntegerMap) => new Placuntiti { IntegerMap = IntegerMap };
+ }
+
+ public partial struct Plectopterous
+ {
+ public double? Double;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Plectopterous(double Double) => new Plectopterous { Double = Double };
+ public static implicit operator Plectopterous(Dictionary IntegerMap) => new Plectopterous { IntegerMap = IntegerMap };
+ }
+
+ public partial struct Poliorcetic
+ {
+ public bool? Bool;
+ public MonaziteClass? MonaziteClass;
+
+ public static implicit operator Poliorcetic(bool Bool) => new Poliorcetic { Bool = Bool };
+ public static implicit operator Poliorcetic(MonaziteClass MonaziteClass) => new Poliorcetic { MonaziteClass = MonaziteClass };
+ }
+
+ public partial struct Poormaster
+ {
+ public long[]? IntegerArray;
+ public Dictionary? IntegerMap;
+
+ public static implicit operator Poormaster(long[] IntegerArray) => new Poormaster { IntegerArray = IntegerArray };
+ public static implicit operator Poormaster(Dictionary IntegerMap) => new Poormaster { IntegerMap = IntegerMap };
+ public bool IsNull => IntegerArray == null && IntegerMap == null;
+ }
+
+ public partial struct PotwhiskyElement
+ {
+ public long? Integer;
+ public PotwhiskyClass? PotwhiskyClass;
+
+ public static implicit operator PotwhiskyElement(long Integer) => new PotwhiskyElement { Integer = Integer };
+ public static implicit operator PotwhiskyElement(PotwhiskyClass PotwhiskyClass) => new PotwhiskyElement { PotwhiskyClass = PotwhiskyClass };
+ public bool IsNull => PotwhiskyClass == null && Integer == null;
+ }
+
+ public partial struct Practicalizer
+ {
+ public MonaziteClass? MonaziteClass;
+ public object[]? NullArray;
+ public string? String;
+
+ public static implicit operator Practicalizer(MonaziteClass MonaziteClass) => new Practicalizer { MonaziteClass = MonaziteClass };
+ public static implicit operator Practicalizer(object[] NullArray) => new Practicalizer { NullArray = NullArray };
+ public static implicit operator Practicalizer(string String) => new Practicalizer { String = String };
+ }
+
+ public partial struct PrefreshmanElement
+ {
+ public object[]? NullArray;
+ public PrefreshmanClass? PrefreshmanClass;
+ public string? String;
+
+ public static implicit operator PrefreshmanElement(object[] NullArray) => new PrefreshmanElement { NullArray = NullArray };
+ public static implicit operator PrefreshmanElement(PrefreshmanClass PrefreshmanClass) => new PrefreshmanElement { PrefreshmanClass = PrefreshmanClass };
+ public static implicit operator PrefreshmanElement(string String) => new PrefreshmanElement { String = String };
+ }
+
+ public partial struct Prehensility
+ {
+ public bool? Bool;
+ public MonaziteClass? MonaziteClass;
+ public object[]? NullArray;
+
+ public static implicit operator Prehensility(bool Bool) => new Prehensility { Bool = Bool };
+ public static implicit operator Prehensility(MonaziteClass MonaziteClass) => new Prehensility { MonaziteClass = MonaziteClass };
+ public static implicit operator Prehensility(object[] NullArray) => new Prehensility { NullArray = NullArray };
+ }
+
+ public partial struct Prevoidance
+ {
+ public long? Integer;
+ public long[]? IntegerArray;
+ public MonaziteClass? MonaziteClass;
+
+ public static implicit operator Prevoidance(long Integer) => new Prevoidance { Integer = Integer };
+ public static implicit operator Prevoidance(long[] IntegerArray) => new Prevoidance { IntegerArray = IntegerArray };
+ public static implicit operator Prevoidance(MonaziteClass MonaziteClass) => new Prevoidance { MonaziteClass = MonaziteClass };
+ }
+
+ public partial struct Protext
+ {
+ public bool? Bool;
+ public long[]? IntegerArray;
+ public MonaziteClass? MonaziteClass;
+
+ public static implicit operator Protext(bool Bool) => new Protext { Bool = Bool };
+ public static implicit operator Protext(long[] IntegerArray) => new Protext { IntegerArray = IntegerArray };
+ public static implicit operator Protext(MonaziteClass MonaziteClass) => new Protext { MonaziteClass = MonaziteClass };
+ }
+
+ public partial class TopLevel
+ {
+ public static TopLevel? FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings);
+ }
+
+ public static partial class Serialize
+ {
+ public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
+ }
+
+ internal static partial class Converter
+ {
+ public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
+ {
+ MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
+ DateParseHandling = DateParseHandling.None,
+ Converters =
+ {
+ JurorElementConverter.Singleton,
+ KongoniConverter.Singleton,
+ LadronismElementConverter.Singleton,
+ LandlubberlyElementConverter.Singleton,
+ ListenerConverter.Singleton,
+ LupusElementConverter.Singleton,
+ MonaziteElementConverter.Singleton,
+ MonoliteralConverter.Singleton,
+ MonotheisticallyElementConverter.Singleton,
+ MontageConverter.Singleton,
+ MoralnessConverter.Singleton,
+ MulishlyConverter.Singleton,
+ MyoscopeConverter.Singleton,
+ NeuromasticConverter.Singleton,
+ NonnervousConverter.Singleton,
+ NonvaluationConverter.Singleton,
+ OccupationalistElementConverter.Singleton,
+ OutrivalElementConverter.Singleton,
+ PaleographicallyConverter.Singleton,
+ PamphletwiseConverter.Singleton,
+ PediatricConverter.Singleton,
+ PiaculumElementConverter.Singleton,
+ PiccadillyConverter.Singleton,
+ PifflerConverter.Singleton,
+ PithfulConverter.Singleton,
+ PlacuntitiConverter.Singleton,
+ PlectopterousConverter.Singleton,
+ PoliorceticConverter.Singleton,
+ PoormasterConverter.Singleton,
+ PotwhiskyElementConverter.Singleton,
+ PracticalizerConverter.Singleton,
+ PrefreshmanElementConverter.Singleton,
+ PrehensilityConverter.Singleton,
+ PrevoidanceConverter.Singleton,
+ ProtextConverter.Singleton,
+ new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
+ },
+ };
+ }
+
+ internal class JurorElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(JurorElement) || t == typeof(JurorElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new JurorElement { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new JurorElement { JurorClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type JurorElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (JurorElement)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.JurorClass != null)
+ {
+ serializer.Serialize(writer, value.JurorClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type JurorElement");
+ }
+
+ public static readonly JurorElementConverter Singleton = new JurorElementConverter();
+ }
+
+ internal class KongoniConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Kongoni) || t == typeof(Kongoni?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize>(reader);
+ return new Kongoni { IntegerMap = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Kongoni { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Kongoni");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Kongoni)untypedValue;
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ if (value.IntegerMap != null)
+ {
+ serializer.Serialize(writer, value.IntegerMap);
+ return;
+ }
+ throw new Exception("Cannot marshal type Kongoni");
+ }
+
+ public static readonly KongoniConverter Singleton = new KongoniConverter();
+ }
+
+ internal class LadronismElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(LadronismElement) || t == typeof(LadronismElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new LadronismElement { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new LadronismElement { String = stringValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new LadronismElement { LadronismClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type LadronismElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (LadronismElement)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.LadronismClass != null)
+ {
+ serializer.Serialize(writer, value.LadronismClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type LadronismElement");
+ }
+
+ public static readonly LadronismElementConverter Singleton = new LadronismElementConverter();
+ }
+
+ internal class LandlubberlyElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(LandlubberlyElement) || t == typeof(LandlubberlyElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new LandlubberlyElement { Integer = integerValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new LandlubberlyElement { Bool = boolValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new LandlubberlyElement { LandlubberlyClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type LandlubberlyElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (LandlubberlyElement)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.LandlubberlyClass != null)
+ {
+ serializer.Serialize(writer, value.LandlubberlyClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type LandlubberlyElement");
+ }
+
+ public static readonly LandlubberlyElementConverter Singleton = new LandlubberlyElementConverter();
+ }
+
+ internal class ListenerConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Listener) || t == typeof(Listener?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Listener { Integer = integerValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Listener { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Listener");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Listener)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Listener");
+ }
+
+ public static readonly ListenerConverter Singleton = new ListenerConverter();
+ }
+
+ internal class LupusElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(LupusElement) || t == typeof(LupusElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new LupusElement { Integer = integerValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new LupusElement { LupusClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type LupusElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (LupusElement)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.LupusClass != null)
+ {
+ serializer.Serialize(writer, value.LupusClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type LupusElement");
+ }
+
+ public static readonly LupusElementConverter Singleton = new LupusElementConverter();
+ }
+
+ internal class MonaziteElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(MonaziteElement) || t == typeof(MonaziteElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new MonaziteElement { Double = doubleValue };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new MonaziteElement { MonaziteClass = objectValue };
+ }
+ throw new Exception("Cannot unmarshal type MonaziteElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (MonaziteElement)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.MonaziteClass != null)
+ {
+ serializer.Serialize(writer, value.MonaziteClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type MonaziteElement");
+ }
+
+ public static readonly MonaziteElementConverter Singleton = new MonaziteElementConverter();
+ }
+
+ internal class MonoliteralConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Monoliteral) || t == typeof(Monoliteral?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Monoliteral { Bool = boolValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Monoliteral { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Monoliteral");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Monoliteral)untypedValue;
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Monoliteral");
+ }
+
+ public static readonly MonoliteralConverter Singleton = new MonoliteralConverter();
+ }
+
+ internal class MonotheisticallyElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(MonotheisticallyElement) || t == typeof(MonotheisticallyElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize(reader);
+ return new MonotheisticallyElement { MonotheisticallyClass = objectValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new MonotheisticallyElement { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type MonotheisticallyElement");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (MonotheisticallyElement)untypedValue;
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ if (value.MonotheisticallyClass != null)
+ {
+ serializer.Serialize(writer, value.MonotheisticallyClass);
+ return;
+ }
+ throw new Exception("Cannot marshal type MonotheisticallyElement");
+ }
+
+ public static readonly MonotheisticallyElementConverter Singleton = new MonotheisticallyElementConverter();
+ }
+
+ internal class MontageConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Montage) || t == typeof(Montage?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Montage { Double = doubleValue };
+ case JsonToken.String:
+ case JsonToken.Date:
+ var stringValue = serializer.Deserialize(reader);
+ return new Montage { String = stringValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Montage { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Montage");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Montage)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.String != null)
+ {
+ serializer.Serialize(writer, value.String);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Montage");
+ }
+
+ public static readonly MontageConverter Singleton = new MontageConverter();
+ }
+
+ internal class MoralnessConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Moralness) || t == typeof(Moralness?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Moralness { };
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Moralness { Double = doubleValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Moralness { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Moralness");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Moralness)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Moralness");
+ }
+
+ public static readonly MoralnessConverter Singleton = new MoralnessConverter();
+ }
+
+ internal class MulishlyConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Mulishly) || t == typeof(Mulishly?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new Mulishly { };
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Mulishly { Double = doubleValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Mulishly { IntegerArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Mulishly");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Mulishly)untypedValue;
+ if (value.IsNull)
+ {
+ serializer.Serialize(writer, null);
+ return;
+ }
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.IntegerArray != null)
+ {
+ serializer.Serialize(writer, value.IntegerArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Mulishly");
+ }
+
+ public static readonly MulishlyConverter Singleton = new MulishlyConverter();
+ }
+
+ internal class MyoscopeConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Myoscope) || t == typeof(Myoscope?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Myoscope { Integer = integerValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Myoscope { Bool = boolValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Myoscope { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Myoscope");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Myoscope)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Myoscope");
+ }
+
+ public static readonly MyoscopeConverter Singleton = new MyoscopeConverter();
+ }
+
+ internal class NeuromasticConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Neuromastic) || t == typeof(Neuromastic?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Neuromastic { Double = doubleValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Neuromastic { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Neuromastic");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Neuromastic)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Neuromastic");
+ }
+
+ public static readonly NeuromasticConverter Singleton = new NeuromasticConverter();
+ }
+
+ internal class NonnervousConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Nonnervous) || t == typeof(Nonnervous?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ var integerValue = serializer.Deserialize(reader);
+ return new Nonnervous { Integer = integerValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Nonnervous { Bool = boolValue };
+ }
+ throw new Exception("Cannot unmarshal type Nonnervous");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Nonnervous)untypedValue;
+ if (value.Integer != null)
+ {
+ serializer.Serialize(writer, value.Integer.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ throw new Exception("Cannot marshal type Nonnervous");
+ }
+
+ public static readonly NonnervousConverter Singleton = new NonnervousConverter();
+ }
+
+ internal class NonvaluationConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(Nonvaluation) || t == typeof(Nonvaluation?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Integer:
+ case JsonToken.Float:
+ var doubleValue = serializer.Deserialize(reader);
+ return new Nonvaluation { Double = doubleValue };
+ case JsonToken.Boolean:
+ var boolValue = serializer.Deserialize(reader);
+ return new Nonvaluation { Bool = boolValue };
+ case JsonToken.StartArray:
+ var arrayValue = serializer.Deserialize(reader);
+ return new Nonvaluation { NullArray = arrayValue };
+ }
+ throw new Exception("Cannot unmarshal type Nonvaluation");
+ }
+
+ public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+ {
+ var value = (Nonvaluation)untypedValue;
+ if (value.Double != null)
+ {
+ serializer.Serialize(writer, value.Double.Value);
+ return;
+ }
+ if (value.Bool != null)
+ {
+ serializer.Serialize(writer, value.Bool.Value);
+ return;
+ }
+ if (value.NullArray != null)
+ {
+ serializer.Serialize(writer, value.NullArray);
+ return;
+ }
+ throw new Exception("Cannot marshal type Nonvaluation");
+ }
+
+ public static readonly NonvaluationConverter Singleton = new NonvaluationConverter();
+ }
+
+ internal class OccupationalistElementConverter : JsonConverter
+ {
+ public override bool CanConvert(Type t) => t == typeof(OccupationalistElement) || t == typeof(OccupationalistElement?);
+
+ public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+ {
+ switch (reader.TokenType)
+ {
+ case JsonToken.Null:
+ return new OccupationalistElement { };
+ case JsonToken.StartObject:
+ var objectValue = serializer.Deserialize