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