diff --git a/head/cplusplus/test/inputs/json/priority/combinations1.json/code-format-with-struct--67c848c66185/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations1.json/code-format-with-struct--67c848c66185/quicktype.hpp
new file mode 100644
index 0000000..8735814
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations1.json/code-format-with-struct--67c848c66185/quicktype.hpp
@@ -0,0 +1,2110 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    struct CerographClass {
+        nlohmann::json apotropaion;
+        nlohmann::json casuary;
+        nlohmann::json creaker;
+        nlohmann::json disqualification;
+        nlohmann::json imperatorious;
+        nlohmann::json impermeabilize;
+        nlohmann::json metastoma;
+        nlohmann::json noctidiurnal;
+        nlohmann::json nonreserve;
+        nlohmann::json ophthalmotonometry;
+        nlohmann::json pailful;
+        nlohmann::json pigfish;
+        nlohmann::json pongee;
+        nlohmann::json prosodical;
+        nlohmann::json scrofuloderm;
+        nlohmann::json storekeeping;
+        nlohmann::json therologist;
+        nlohmann::json tolowa;
+        nlohmann::json tradeful;
+        nlohmann::json unriveting;
+    };
+
+    using CerographElement = std::optional<std::variant<CerographClass, std::string>>;
+
+    struct ChemotherapeuticClass {
+        nlohmann::json angioneurotic;
+        nlohmann::json availment;
+        nlohmann::json bladelet;
+        std::optional<double> catharticalness;
+        nlohmann::json caulis;
+        nlohmann::json chalcus;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enteradenological;
+        std::optional<bool> homocerc;
+        nlohmann::json imporosity;
+        nlohmann::json insistently;
+        nlohmann::json intraparietal;
+        nlohmann::json ivied;
+        nlohmann::json maureen;
+        nlohmann::json nonbookish;
+        nlohmann::json nostochine;
+        nlohmann::json nutcracker;
+        nlohmann::json ofttimes;
+        nlohmann::json phenocryst;
+        nlohmann::json precoincident;
+        nlohmann::json ramiferous;
+        nlohmann::json stagmometer;
+        nlohmann::json tetherball;
+        nlohmann::json unshy;
+    };
+
+    using ChemotherapeuticElement = std::variant<ChemotherapeuticClass, int64_t>;
+
+    struct CimeliaClass {
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+    };
+
+    using CimeliaElement = std::optional<std::variant<std::vector<int64_t>, CimeliaClass>>;
+
+    using Clinodome = std::variant<double, std::string>;
+
+    struct CoadjustClass {
+        nlohmann::json amidosulphonal;
+        nlohmann::json benny;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json ensnare;
+        std::optional<bool> homocerc;
+        nlohmann::json hybridizer;
+        nlohmann::json leastwise;
+        nlohmann::json lof;
+        nlohmann::json monkhood;
+        nlohmann::json netherlandish;
+        nlohmann::json nonbookish;
+        nlohmann::json peonism;
+        nlohmann::json phonelescope;
+        nlohmann::json porphyrogeniture;
+        nlohmann::json preindemnify;
+        nlohmann::json rosal;
+        nlohmann::json scalenous;
+        nlohmann::json scopine;
+        nlohmann::json sedaceae;
+        nlohmann::json suberinize;
+        nlohmann::json symbiot;
+        nlohmann::json tablefellow;
+        nlohmann::json unchargeable;
+    };
+
+    using CoadjustElement = std::variant<CoadjustClass, double>;
+
+    using Consilience = std::variant<double, std::map<std::string, int64_t>>;
+
+    using Constructor = std::variant<bool, std::map<std::string, std::optional<int64_t>>>;
+
+    using Continuative = std::variant<std::map<std::string, int64_t>, std::string>;
+
+    struct CredulityClass {
+        nlohmann::json ammonolytic;
+        nlohmann::json bushmaster;
+        nlohmann::json considering;
+        nlohmann::json consuetudinary;
+        nlohmann::json embarras;
+        nlohmann::json fineness;
+        nlohmann::json flaithship;
+        nlohmann::json flavia;
+        nlohmann::json gruffly;
+        nlohmann::json hedychium;
+        nlohmann::json leadwort;
+        nlohmann::json overseriously;
+        nlohmann::json parabola;
+        nlohmann::json pectinatodenticulate;
+        nlohmann::json popean;
+        nlohmann::json pornocrat;
+        nlohmann::json quadrisect;
+        nlohmann::json seriality;
+        nlohmann::json vamphorn;
+        nlohmann::json wharp;
+    };
+
+    using CredulityElement = std::variant<CredulityClass, int64_t, std::string>;
+
+    using Creviced = std::variant<bool, std::map<std::string, int64_t>, std::string>;
+
+    struct DeruralizeClass {
+        nlohmann::json bockerel;
+        nlohmann::json boulder;
+        nlohmann::json churrus;
+        nlohmann::json counterdigged;
+        nlohmann::json dialogite;
+        nlohmann::json digenic;
+        nlohmann::json dunbird;
+        nlohmann::json ergatogyne;
+        nlohmann::json fiendful;
+        nlohmann::json jackrod;
+        nlohmann::json jehovistic;
+        nlohmann::json paninean;
+        nlohmann::json panther;
+        nlohmann::json placentigerous;
+        nlohmann::json romney;
+        nlohmann::json sparm;
+        nlohmann::json tocsin;
+        nlohmann::json unnicked;
+        nlohmann::json unstavable;
+        nlohmann::json windfirm;
+    };
+
+    using DeruralizeElement = std::variant<std::vector<nlohmann::json>, bool, DeruralizeClass>;
+
+    struct DiaereseClass {
+        nlohmann::json amoreuxia;
+        nlohmann::json ani;
+        nlohmann::json bernicle;
+        nlohmann::json blackwasher;
+        nlohmann::json blowhard;
+        nlohmann::json broma;
+        nlohmann::json closecross;
+        nlohmann::json congregationalism;
+        nlohmann::json grayly;
+        nlohmann::json historically;
+        nlohmann::json hoast;
+        nlohmann::json irretentive;
+        nlohmann::json parcener;
+        nlohmann::json pedder;
+        nlohmann::json pseudoanatomic;
+        nlohmann::json rhizocarpian;
+        nlohmann::json samel;
+        nlohmann::json silker;
+        nlohmann::json subdentated;
+        nlohmann::json subobscure;
+    };
+
+    using DiaereseElement = std::variant<std::vector<int64_t>, bool, DiaereseClass>;
+
+    using Downstroke = std::variant<std::vector<nlohmann::json>, bool, std::string>;
+
+    using Eleutheromania = std::variant<double, std::map<std::string, int64_t>, std::string>;
+
+    struct Encrust {
+        nlohmann::json comradely;
+        nlohmann::json diacanthous;
+        nlohmann::json feminineness;
+        nlohmann::json gossamered;
+        nlohmann::json hibernia;
+        nlohmann::json hibiscus;
+        nlohmann::json lepidosauria;
+        nlohmann::json lollingly;
+        nlohmann::json manager;
+        nlohmann::json mechanic;
+        nlohmann::json overminuteness;
+        nlohmann::json papelonne;
+        nlohmann::json plebification;
+        nlohmann::json pugmiller;
+        nlohmann::json recoveror;
+        nlohmann::json spermatoblastic;
+        nlohmann::json syllidae;
+        nlohmann::json ungyved;
+        nlohmann::json whirlabout;
+        nlohmann::json woodenware;
+    };
+
+    using Entomoid = std::variant<CimeliaClass, int64_t>;
+
+    using Epipaleolithic = std::variant<std::vector<int64_t>, double>;
+
+    using Expropriable = std::variant<std::vector<nlohmann::json>, CimeliaClass, double>;
+
+    struct FagginglyClass {
+        nlohmann::json abranchian;
+        nlohmann::json aculeiform;
+        nlohmann::json adiaphoristic;
+        nlohmann::json adoptionism;
+        nlohmann::json anglic;
+        nlohmann::json antrotomy;
+        nlohmann::json coerciveness;
+        nlohmann::json decorist;
+        nlohmann::json duckhood;
+        nlohmann::json heteromeri;
+        nlohmann::json hypochnose;
+        nlohmann::json lochage;
+        nlohmann::json melee;
+        nlohmann::json nonconformitant;
+        nlohmann::json poinsettia;
+        nlohmann::json putatively;
+        nlohmann::json semivolatile;
+        nlohmann::json soleas;
+        nlohmann::json unfastenable;
+        nlohmann::json unmillinered;
+    };
+
+    using FagginglyElement = std::variant<FagginglyClass, double>;
+
+    struct FenkClass {
+        nlohmann::json apoise;
+        nlohmann::json astronomize;
+        nlohmann::json cockhorse;
+        nlohmann::json copular;
+        nlohmann::json dagomba;
+        nlohmann::json draffy;
+        nlohmann::json foreigner;
+        nlohmann::json guyandot;
+        nlohmann::json neurogliosis;
+        nlohmann::json osmious;
+        nlohmann::json palpitate;
+        nlohmann::json rebukeable;
+        nlohmann::json reinwardtia;
+        nlohmann::json reservatory;
+        nlohmann::json scalt;
+        nlohmann::json scripturalize;
+        nlohmann::json tintometer;
+        nlohmann::json tritoness;
+        nlohmann::json undergrade;
+        nlohmann::json undermountain;
+    };
+
+    using FenkElement = std::variant<FenkClass, std::string>;
+
+    struct FlagmakingClass {
+        nlohmann::json albarco;
+        nlohmann::json bunodonta;
+        nlohmann::json hornify;
+        nlohmann::json hydrocorisae;
+        nlohmann::json hypoglossus;
+        nlohmann::json inexpiably;
+        nlohmann::json ingratitude;
+        nlohmann::json ladyfly;
+        nlohmann::json medicament;
+        nlohmann::json monogrammatic;
+        nlohmann::json nobbut;
+        nlohmann::json notacanthidae;
+        nlohmann::json polyplacophore;
+        nlohmann::json proexercise;
+        nlohmann::json protoplast;
+        nlohmann::json puzzling;
+        nlohmann::json splanchnoskeleton;
+        nlohmann::json unloveliness;
+        nlohmann::json unquarantined;
+        nlohmann::json unrenounceable;
+    };
+
+    using FlagmakingElement = std::variant<bool, FlagmakingClass, double>;
+
+    using Fluorometer = std::optional<std::variant<int64_t, std::string>>;
+
+    using Fuzzy = std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>;
+
+    using Gardenward = std::variant<std::vector<int64_t>, bool, std::string>;
+
+    using Generalissimo = std::optional<std::variant<bool, std::map<std::string, int64_t>>>;
+
+    using Hemicrystalline = std::variant<CimeliaClass, std::string>;
+
+    struct HemocoeleClass {
+        nlohmann::json acrogamy;
+        nlohmann::json amelification;
+        nlohmann::json autobiographic;
+        nlohmann::json berat;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json disproportionably;
+        nlohmann::json erythrite;
+        nlohmann::json graphic;
+        nlohmann::json hepatological;
+        std::optional<bool> homocerc;
+        nlohmann::json incommensurably;
+        nlohmann::json misaffirm;
+        nlohmann::json nonbookish;
+        nlohmann::json pocketbook;
+        nlohmann::json sclerometric;
+        nlohmann::json stambouline;
+        nlohmann::json stickpin;
+        nlohmann::json tubulure;
+        nlohmann::json undelated;
+        nlohmann::json unsalt;
+        nlohmann::json untutelar;
+        nlohmann::json vagrant;
+        nlohmann::json walt;
+    };
+
+    using HemocoeleElement = std::variant<std::vector<int64_t>, HemocoeleClass>;
+
+    using Hoister = std::optional<std::variant<CimeliaClass, std::string>>;
+
+    using Hyperpiesi = std::optional<std::variant<std::vector<nlohmann::json>, CimeliaClass>>;
+
+    using Hyppish = std::optional<std::variant<bool, std::string>>;
+
+    using Idealizer = std::variant<std::vector<nlohmann::json>, CimeliaClass, int64_t>;
+
+    using Incrustator = std::variant<std::vector<int64_t>, int64_t, std::string>;
+
+    using Intentiveness = std::variant<CimeliaClass, double, std::string>;
+
+    struct Interacinar {
+        double assapan;
+        bool benefactorship;
+        std::string triseriatim;
+        int64_t tubbing;
+        nlohmann::json untrimmed;
+    };
+
+    using Jacutinga = std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>;
+
+    struct TopLevel {
+        std::string centrodesmose;
+        std::vector<CerographElement> cerograph;
+        std::vector<ChemotherapeuticElement> chemotherapeutics;
+        std::vector<CimeliaElement> cimelia;
+        int64_t citrated;
+        std::vector<Clinodome> clinodome;
+        std::vector<CoadjustElement> coadjust;
+        std::vector<Consilience> consilience;
+        std::vector<Constructor> constructor;
+        std::vector<Continuative> continuative;
+        std::vector<CredulityElement> credulity;
+        std::vector<Creviced> creviced;
+        std::vector<std::vector<std::optional<int64_t>>> cubiculum;
+        std::vector<DeruralizeElement> deruralize;
+        std::vector<DiaereseElement> diaereses;
+        std::vector<std::optional<std::vector<nlohmann::json>>> dissolution;
+        std::vector<Downstroke> downstroke;
+        std::vector<std::optional<double>> electrotautomerism;
+        std::vector<Eleutheromania> eleutheromania;
+        Encrust encrust;
+        std::vector<Entomoid> entomoid;
+        std::vector<Epipaleolithic> epipaleolithic;
+        std::vector<Expropriable> expropriable;
+        std::vector<FagginglyElement> faggingly;
+        std::vector<FenkElement> fenks;
+        std::vector<FlagmakingElement> flagmaking;
+        std::vector<Fluorometer> fluorometer;
+        std::vector<std::optional<int64_t>> fulsome;
+        std::vector<Fuzzy> fuzzy;
+        std::vector<Gardenward> gardenwards;
+        std::vector<Generalissimo> generalissimo;
+        std::vector<std::optional<std::map<std::string, int64_t>>> habeas;
+        std::vector<Hemicrystalline> hemicrystalline;
+        std::vector<HemocoeleElement> hemocoele;
+        std::vector<Hoister> hoister;
+        std::vector<Hyperpiesi> hyperpiesis;
+        std::vector<Hyppish> hyppish;
+        std::vector<Idealizer> idealizer;
+        std::vector<Incrustator> incrustator;
+        std::vector<Intentiveness> intentiveness;
+        Interacinar interacinar;
+        std::vector<std::optional<std::vector<int64_t>>> intercorrelation;
+        std::vector<Jacutinga> jacutinga;
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, CerographClass & x);
+void to_json(json & j, const CerographClass & x);
+
+void from_json(const json & j, ChemotherapeuticClass & x);
+void to_json(json & j, const ChemotherapeuticClass & x);
+
+void from_json(const json & j, CimeliaClass & x);
+void to_json(json & j, const CimeliaClass & x);
+
+void from_json(const json & j, CoadjustClass & x);
+void to_json(json & j, const CoadjustClass & x);
+
+void from_json(const json & j, CredulityClass & x);
+void to_json(json & j, const CredulityClass & x);
+
+void from_json(const json & j, DeruralizeClass & x);
+void to_json(json & j, const DeruralizeClass & x);
+
+void from_json(const json & j, DiaereseClass & x);
+void to_json(json & j, const DiaereseClass & x);
+
+void from_json(const json & j, Encrust & x);
+void to_json(json & j, const Encrust & x);
+
+void from_json(const json & j, FagginglyClass & x);
+void to_json(json & j, const FagginglyClass & x);
+
+void from_json(const json & j, FenkClass & x);
+void to_json(json & j, const FenkClass & x);
+
+void from_json(const json & j, FlagmakingClass & x);
+void to_json(json & j, const FlagmakingClass & x);
+
+void from_json(const json & j, HemocoeleClass & x);
+void to_json(json & j, const HemocoeleClass & x);
+
+void from_json(const json & j, Interacinar & x);
+void to_json(json & j, const Interacinar & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<quicktype::CerographClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CerographClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CerographClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::ChemotherapeuticClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CoadjustClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::CoadjustClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::CoadjustClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CredulityClass, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CredulityClass, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::CimeliaClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::CimeliaClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FagginglyClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::FagginglyClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::FagginglyClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FenkClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::FenkClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::FenkClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::FlagmakingClass, double> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::FlagmakingClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CimeliaClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CimeliaClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::string>> {
+    static void from_json(const json & j, std::variant<bool, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CimeliaClass, double, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CimeliaClass, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, CerographClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.apotropaion = get_untyped(j, "apotropaion");
+        x.casuary = get_untyped(j, "casuary");
+        x.creaker = get_untyped(j, "creaker");
+        x.disqualification = get_untyped(j, "disqualification");
+        x.imperatorious = get_untyped(j, "imperatorious");
+        x.impermeabilize = get_untyped(j, "impermeabilize");
+        x.metastoma = get_untyped(j, "metastoma");
+        x.noctidiurnal = get_untyped(j, "noctidiurnal");
+        x.nonreserve = get_untyped(j, "nonreserve");
+        x.ophthalmotonometry = get_untyped(j, "ophthalmotonometry");
+        x.pailful = get_untyped(j, "pailful");
+        x.pigfish = get_untyped(j, "pigfish");
+        x.pongee = get_untyped(j, "pongee");
+        x.prosodical = get_untyped(j, "prosodical");
+        x.scrofuloderm = get_untyped(j, "scrofuloderm");
+        x.storekeeping = get_untyped(j, "storekeeping");
+        x.therologist = get_untyped(j, "therologist");
+        x.tolowa = get_untyped(j, "Tolowa");
+        x.tradeful = get_untyped(j, "tradeful");
+        x.unriveting = get_untyped(j, "unriveting");
+    }
+
+    inline void to_json(json & j, const CerographClass & x) {
+        j = json::object();
+        j["apotropaion"] = x.apotropaion;
+        j["casuary"] = x.casuary;
+        j["creaker"] = x.creaker;
+        j["disqualification"] = x.disqualification;
+        j["imperatorious"] = x.imperatorious;
+        j["impermeabilize"] = x.impermeabilize;
+        j["metastoma"] = x.metastoma;
+        j["noctidiurnal"] = x.noctidiurnal;
+        j["nonreserve"] = x.nonreserve;
+        j["ophthalmotonometry"] = x.ophthalmotonometry;
+        j["pailful"] = x.pailful;
+        j["pigfish"] = x.pigfish;
+        j["pongee"] = x.pongee;
+        j["prosodical"] = x.prosodical;
+        j["scrofuloderm"] = x.scrofuloderm;
+        j["storekeeping"] = x.storekeeping;
+        j["therologist"] = x.therologist;
+        j["Tolowa"] = x.tolowa;
+        j["tradeful"] = x.tradeful;
+        j["unriveting"] = x.unriveting;
+    }
+
+    inline void from_json(const json & j, ChemotherapeuticClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.angioneurotic = get_untyped(j, "angioneurotic");
+        x.availment = get_untyped(j, "availment");
+        x.bladelet = get_untyped(j, "bladelet");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.caulis = get_untyped(j, "caulis");
+        x.chalcus = get_untyped(j, "chalcus");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.enteradenological = get_untyped(j, "enteradenological");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.imporosity = get_untyped(j, "imporosity");
+        x.insistently = get_untyped(j, "insistently");
+        x.intraparietal = get_untyped(j, "intraparietal");
+        x.ivied = get_untyped(j, "ivied");
+        x.maureen = get_untyped(j, "Maureen");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.nostochine = get_untyped(j, "nostochine");
+        x.nutcracker = get_untyped(j, "nutcracker");
+        x.ofttimes = get_untyped(j, "ofttimes");
+        x.phenocryst = get_untyped(j, "phenocryst");
+        x.precoincident = get_untyped(j, "precoincident");
+        x.ramiferous = get_untyped(j, "ramiferous");
+        x.stagmometer = get_untyped(j, "stagmometer");
+        x.tetherball = get_untyped(j, "tetherball");
+        x.unshy = get_untyped(j, "unshy");
+    }
+
+    inline void to_json(json & j, const ChemotherapeuticClass & x) {
+        j = json::object();
+        j["angioneurotic"] = x.angioneurotic;
+        j["availment"] = x.availment;
+        j["bladelet"] = x.bladelet;
+        j["catharticalness"] = x.catharticalness;
+        j["caulis"] = x.caulis;
+        j["chalcus"] = x.chalcus;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["enteradenological"] = x.enteradenological;
+        j["homocerc"] = x.homocerc;
+        j["imporosity"] = x.imporosity;
+        j["insistently"] = x.insistently;
+        j["intraparietal"] = x.intraparietal;
+        j["ivied"] = x.ivied;
+        j["Maureen"] = x.maureen;
+        j["nonbookish"] = x.nonbookish;
+        j["nostochine"] = x.nostochine;
+        j["nutcracker"] = x.nutcracker;
+        j["ofttimes"] = x.ofttimes;
+        j["phenocryst"] = x.phenocryst;
+        j["precoincident"] = x.precoincident;
+        j["ramiferous"] = x.ramiferous;
+        j["stagmometer"] = x.stagmometer;
+        j["tetherball"] = x.tetherball;
+        j["unshy"] = x.unshy;
+    }
+
+    inline void from_json(const json & j, CimeliaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.catharticalness = j.at("catharticalness").get<double>();
+        x.chirotherium = j.at("Chirotherium").get<int64_t>();
+        x.disdiapason = j.at("disdiapason").get<std::string>();
+        x.homocerc = j.at("homocerc").get<bool>();
+        x.nonbookish = get_untyped(j, "nonbookish");
+    }
+
+    inline void to_json(json & j, const CimeliaClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["homocerc"] = x.homocerc;
+        j["nonbookish"] = x.nonbookish;
+    }
+
+    inline void from_json(const json & j, CoadjustClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.amidosulphonal = get_untyped(j, "amidosulphonal");
+        x.benny = get_untyped(j, "Benny");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.ensnare = get_untyped(j, "ensnare");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.hybridizer = get_untyped(j, "hybridizer");
+        x.leastwise = get_untyped(j, "leastwise");
+        x.lof = get_untyped(j, "lof");
+        x.monkhood = get_untyped(j, "monkhood");
+        x.netherlandish = get_untyped(j, "Netherlandish");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.peonism = get_untyped(j, "peonism");
+        x.phonelescope = get_untyped(j, "Phonelescope");
+        x.porphyrogeniture = get_untyped(j, "porphyrogeniture");
+        x.preindemnify = get_untyped(j, "preindemnify");
+        x.rosal = get_untyped(j, "rosal");
+        x.scalenous = get_untyped(j, "scalenous");
+        x.scopine = get_untyped(j, "scopine");
+        x.sedaceae = get_untyped(j, "Sedaceae");
+        x.suberinize = get_untyped(j, "suberinize");
+        x.symbiot = get_untyped(j, "symbiot");
+        x.tablefellow = get_untyped(j, "tablefellow");
+        x.unchargeable = get_untyped(j, "unchargeable");
+    }
+
+    inline void to_json(json & j, const CoadjustClass & x) {
+        j = json::object();
+        j["amidosulphonal"] = x.amidosulphonal;
+        j["Benny"] = x.benny;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["ensnare"] = x.ensnare;
+        j["homocerc"] = x.homocerc;
+        j["hybridizer"] = x.hybridizer;
+        j["leastwise"] = x.leastwise;
+        j["lof"] = x.lof;
+        j["monkhood"] = x.monkhood;
+        j["Netherlandish"] = x.netherlandish;
+        j["nonbookish"] = x.nonbookish;
+        j["peonism"] = x.peonism;
+        j["Phonelescope"] = x.phonelescope;
+        j["porphyrogeniture"] = x.porphyrogeniture;
+        j["preindemnify"] = x.preindemnify;
+        j["rosal"] = x.rosal;
+        j["scalenous"] = x.scalenous;
+        j["scopine"] = x.scopine;
+        j["Sedaceae"] = x.sedaceae;
+        j["suberinize"] = x.suberinize;
+        j["symbiot"] = x.symbiot;
+        j["tablefellow"] = x.tablefellow;
+        j["unchargeable"] = x.unchargeable;
+    }
+
+    inline void from_json(const json & j, CredulityClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.ammonolytic = get_untyped(j, "ammonolytic");
+        x.bushmaster = get_untyped(j, "bushmaster");
+        x.considering = get_untyped(j, "considering");
+        x.consuetudinary = get_untyped(j, "consuetudinary");
+        x.embarras = get_untyped(j, "embarras");
+        x.fineness = get_untyped(j, "fineness");
+        x.flaithship = get_untyped(j, "flaithship");
+        x.flavia = get_untyped(j, "Flavia");
+        x.gruffly = get_untyped(j, "gruffly");
+        x.hedychium = get_untyped(j, "Hedychium");
+        x.leadwort = get_untyped(j, "leadwort");
+        x.overseriously = get_untyped(j, "overseriously");
+        x.parabola = get_untyped(j, "parabola");
+        x.pectinatodenticulate = get_untyped(j, "pectinatodenticulate");
+        x.popean = get_untyped(j, "Popean");
+        x.pornocrat = get_untyped(j, "pornocrat");
+        x.quadrisect = get_untyped(j, "quadrisect");
+        x.seriality = get_untyped(j, "seriality");
+        x.vamphorn = get_untyped(j, "vamphorn");
+        x.wharp = get_untyped(j, "wharp");
+    }
+
+    inline void to_json(json & j, const CredulityClass & x) {
+        j = json::object();
+        j["ammonolytic"] = x.ammonolytic;
+        j["bushmaster"] = x.bushmaster;
+        j["considering"] = x.considering;
+        j["consuetudinary"] = x.consuetudinary;
+        j["embarras"] = x.embarras;
+        j["fineness"] = x.fineness;
+        j["flaithship"] = x.flaithship;
+        j["Flavia"] = x.flavia;
+        j["gruffly"] = x.gruffly;
+        j["Hedychium"] = x.hedychium;
+        j["leadwort"] = x.leadwort;
+        j["overseriously"] = x.overseriously;
+        j["parabola"] = x.parabola;
+        j["pectinatodenticulate"] = x.pectinatodenticulate;
+        j["Popean"] = x.popean;
+        j["pornocrat"] = x.pornocrat;
+        j["quadrisect"] = x.quadrisect;
+        j["seriality"] = x.seriality;
+        j["vamphorn"] = x.vamphorn;
+        j["wharp"] = x.wharp;
+    }
+
+    inline void from_json(const json & j, DeruralizeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.bockerel = get_untyped(j, "bockerel");
+        x.boulder = get_untyped(j, "boulder");
+        x.churrus = get_untyped(j, "churrus");
+        x.counterdigged = get_untyped(j, "counterdigged");
+        x.dialogite = get_untyped(j, "dialogite");
+        x.digenic = get_untyped(j, "digenic");
+        x.dunbird = get_untyped(j, "dunbird");
+        x.ergatogyne = get_untyped(j, "ergatogyne");
+        x.fiendful = get_untyped(j, "fiendful");
+        x.jackrod = get_untyped(j, "jackrod");
+        x.jehovistic = get_untyped(j, "Jehovistic");
+        x.paninean = get_untyped(j, "Paninean");
+        x.panther = get_untyped(j, "panther");
+        x.placentigerous = get_untyped(j, "placentigerous");
+        x.romney = get_untyped(j, "Romney");
+        x.sparm = get_untyped(j, "sparm");
+        x.tocsin = get_untyped(j, "tocsin");
+        x.unnicked = get_untyped(j, "unnicked");
+        x.unstavable = get_untyped(j, "unstavable");
+        x.windfirm = get_untyped(j, "windfirm");
+    }
+
+    inline void to_json(json & j, const DeruralizeClass & x) {
+        j = json::object();
+        j["bockerel"] = x.bockerel;
+        j["boulder"] = x.boulder;
+        j["churrus"] = x.churrus;
+        j["counterdigged"] = x.counterdigged;
+        j["dialogite"] = x.dialogite;
+        j["digenic"] = x.digenic;
+        j["dunbird"] = x.dunbird;
+        j["ergatogyne"] = x.ergatogyne;
+        j["fiendful"] = x.fiendful;
+        j["jackrod"] = x.jackrod;
+        j["Jehovistic"] = x.jehovistic;
+        j["Paninean"] = x.paninean;
+        j["panther"] = x.panther;
+        j["placentigerous"] = x.placentigerous;
+        j["Romney"] = x.romney;
+        j["sparm"] = x.sparm;
+        j["tocsin"] = x.tocsin;
+        j["unnicked"] = x.unnicked;
+        j["unstavable"] = x.unstavable;
+        j["windfirm"] = x.windfirm;
+    }
+
+    inline void from_json(const json & j, DiaereseClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.amoreuxia = get_untyped(j, "Amoreuxia");
+        x.ani = get_untyped(j, "ani");
+        x.bernicle = get_untyped(j, "bernicle");
+        x.blackwasher = get_untyped(j, "blackwasher");
+        x.blowhard = get_untyped(j, "blowhard");
+        x.broma = get_untyped(j, "broma");
+        x.closecross = get_untyped(j, "closecross");
+        x.congregationalism = get_untyped(j, "congregationalism");
+        x.grayly = get_untyped(j, "grayly");
+        x.historically = get_untyped(j, "historically");
+        x.hoast = get_untyped(j, "hoast");
+        x.irretentive = get_untyped(j, "irretentive");
+        x.parcener = get_untyped(j, "parcener");
+        x.pedder = get_untyped(j, "pedder");
+        x.pseudoanatomic = get_untyped(j, "pseudoanatomic");
+        x.rhizocarpian = get_untyped(j, "rhizocarpian");
+        x.samel = get_untyped(j, "samel");
+        x.silker = get_untyped(j, "silker");
+        x.subdentated = get_untyped(j, "subdentated");
+        x.subobscure = get_untyped(j, "subobscure");
+    }
+
+    inline void to_json(json & j, const DiaereseClass & x) {
+        j = json::object();
+        j["Amoreuxia"] = x.amoreuxia;
+        j["ani"] = x.ani;
+        j["bernicle"] = x.bernicle;
+        j["blackwasher"] = x.blackwasher;
+        j["blowhard"] = x.blowhard;
+        j["broma"] = x.broma;
+        j["closecross"] = x.closecross;
+        j["congregationalism"] = x.congregationalism;
+        j["grayly"] = x.grayly;
+        j["historically"] = x.historically;
+        j["hoast"] = x.hoast;
+        j["irretentive"] = x.irretentive;
+        j["parcener"] = x.parcener;
+        j["pedder"] = x.pedder;
+        j["pseudoanatomic"] = x.pseudoanatomic;
+        j["rhizocarpian"] = x.rhizocarpian;
+        j["samel"] = x.samel;
+        j["silker"] = x.silker;
+        j["subdentated"] = x.subdentated;
+        j["subobscure"] = x.subobscure;
+    }
+
+    inline void from_json(const json & j, Encrust& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.comradely = get_untyped(j, "comradely");
+        x.diacanthous = get_untyped(j, "diacanthous");
+        x.feminineness = get_untyped(j, "feminineness");
+        x.gossamered = get_untyped(j, "gossamered");
+        x.hibernia = get_untyped(j, "Hibernia");
+        x.hibiscus = get_untyped(j, "Hibiscus");
+        x.lepidosauria = get_untyped(j, "Lepidosauria");
+        x.lollingly = get_untyped(j, "lollingly");
+        x.manager = get_untyped(j, "manager");
+        x.mechanic = get_untyped(j, "mechanic");
+        x.overminuteness = get_untyped(j, "overminuteness");
+        x.papelonne = get_untyped(j, "papelonne");
+        x.plebification = get_untyped(j, "plebification");
+        x.pugmiller = get_untyped(j, "pugmiller");
+        x.recoveror = get_untyped(j, "recoveror");
+        x.spermatoblastic = get_untyped(j, "spermatoblastic");
+        x.syllidae = get_untyped(j, "Syllidae");
+        x.ungyved = get_untyped(j, "ungyved");
+        x.whirlabout = get_untyped(j, "whirlabout");
+        x.woodenware = get_untyped(j, "woodenware");
+    }
+
+    inline void to_json(json & j, const Encrust & x) {
+        j = json::object();
+        j["comradely"] = x.comradely;
+        j["diacanthous"] = x.diacanthous;
+        j["feminineness"] = x.feminineness;
+        j["gossamered"] = x.gossamered;
+        j["Hibernia"] = x.hibernia;
+        j["Hibiscus"] = x.hibiscus;
+        j["Lepidosauria"] = x.lepidosauria;
+        j["lollingly"] = x.lollingly;
+        j["manager"] = x.manager;
+        j["mechanic"] = x.mechanic;
+        j["overminuteness"] = x.overminuteness;
+        j["papelonne"] = x.papelonne;
+        j["plebification"] = x.plebification;
+        j["pugmiller"] = x.pugmiller;
+        j["recoveror"] = x.recoveror;
+        j["spermatoblastic"] = x.spermatoblastic;
+        j["Syllidae"] = x.syllidae;
+        j["ungyved"] = x.ungyved;
+        j["whirlabout"] = x.whirlabout;
+        j["woodenware"] = x.woodenware;
+    }
+
+    inline void from_json(const json & j, FagginglyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.abranchian = get_untyped(j, "abranchian");
+        x.aculeiform = get_untyped(j, "aculeiform");
+        x.adiaphoristic = get_untyped(j, "adiaphoristic");
+        x.adoptionism = get_untyped(j, "adoptionism");
+        x.anglic = get_untyped(j, "Anglic");
+        x.antrotomy = get_untyped(j, "antrotomy");
+        x.coerciveness = get_untyped(j, "coerciveness");
+        x.decorist = get_untyped(j, "decorist");
+        x.duckhood = get_untyped(j, "duckhood");
+        x.heteromeri = get_untyped(j, "Heteromeri");
+        x.hypochnose = get_untyped(j, "hypochnose");
+        x.lochage = get_untyped(j, "lochage");
+        x.melee = get_untyped(j, "melee");
+        x.nonconformitant = get_untyped(j, "nonconformitant");
+        x.poinsettia = get_untyped(j, "Poinsettia");
+        x.putatively = get_untyped(j, "putatively");
+        x.semivolatile = get_untyped(j, "semivolatile");
+        x.soleas = get_untyped(j, "soleas");
+        x.unfastenable = get_untyped(j, "unfastenable");
+        x.unmillinered = get_untyped(j, "unmillinered");
+    }
+
+    inline void to_json(json & j, const FagginglyClass & x) {
+        j = json::object();
+        j["abranchian"] = x.abranchian;
+        j["aculeiform"] = x.aculeiform;
+        j["adiaphoristic"] = x.adiaphoristic;
+        j["adoptionism"] = x.adoptionism;
+        j["Anglic"] = x.anglic;
+        j["antrotomy"] = x.antrotomy;
+        j["coerciveness"] = x.coerciveness;
+        j["decorist"] = x.decorist;
+        j["duckhood"] = x.duckhood;
+        j["Heteromeri"] = x.heteromeri;
+        j["hypochnose"] = x.hypochnose;
+        j["lochage"] = x.lochage;
+        j["melee"] = x.melee;
+        j["nonconformitant"] = x.nonconformitant;
+        j["Poinsettia"] = x.poinsettia;
+        j["putatively"] = x.putatively;
+        j["semivolatile"] = x.semivolatile;
+        j["soleas"] = x.soleas;
+        j["unfastenable"] = x.unfastenable;
+        j["unmillinered"] = x.unmillinered;
+    }
+
+    inline void from_json(const json & j, FenkClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.apoise = get_untyped(j, "apoise");
+        x.astronomize = get_untyped(j, "astronomize");
+        x.cockhorse = get_untyped(j, "cockhorse");
+        x.copular = get_untyped(j, "copular");
+        x.dagomba = get_untyped(j, "Dagomba");
+        x.draffy = get_untyped(j, "draffy");
+        x.foreigner = get_untyped(j, "foreigner");
+        x.guyandot = get_untyped(j, "Guyandot");
+        x.neurogliosis = get_untyped(j, "neurogliosis");
+        x.osmious = get_untyped(j, "osmious");
+        x.palpitate = get_untyped(j, "palpitate");
+        x.rebukeable = get_untyped(j, "rebukeable");
+        x.reinwardtia = get_untyped(j, "Reinwardtia");
+        x.reservatory = get_untyped(j, "reservatory");
+        x.scalt = get_untyped(j, "scalt");
+        x.scripturalize = get_untyped(j, "scripturalize");
+        x.tintometer = get_untyped(j, "tintometer");
+        x.tritoness = get_untyped(j, "Tritoness");
+        x.undergrade = get_untyped(j, "undergrade");
+        x.undermountain = get_untyped(j, "undermountain");
+    }
+
+    inline void to_json(json & j, const FenkClass & x) {
+        j = json::object();
+        j["apoise"] = x.apoise;
+        j["astronomize"] = x.astronomize;
+        j["cockhorse"] = x.cockhorse;
+        j["copular"] = x.copular;
+        j["Dagomba"] = x.dagomba;
+        j["draffy"] = x.draffy;
+        j["foreigner"] = x.foreigner;
+        j["Guyandot"] = x.guyandot;
+        j["neurogliosis"] = x.neurogliosis;
+        j["osmious"] = x.osmious;
+        j["palpitate"] = x.palpitate;
+        j["rebukeable"] = x.rebukeable;
+        j["Reinwardtia"] = x.reinwardtia;
+        j["reservatory"] = x.reservatory;
+        j["scalt"] = x.scalt;
+        j["scripturalize"] = x.scripturalize;
+        j["tintometer"] = x.tintometer;
+        j["Tritoness"] = x.tritoness;
+        j["undergrade"] = x.undergrade;
+        j["undermountain"] = x.undermountain;
+    }
+
+    inline void from_json(const json & j, FlagmakingClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.albarco = get_untyped(j, "albarco");
+        x.bunodonta = get_untyped(j, "Bunodonta");
+        x.hornify = get_untyped(j, "hornify");
+        x.hydrocorisae = get_untyped(j, "Hydrocorisae");
+        x.hypoglossus = get_untyped(j, "hypoglossus");
+        x.inexpiably = get_untyped(j, "inexpiably");
+        x.ingratitude = get_untyped(j, "ingratitude");
+        x.ladyfly = get_untyped(j, "ladyfly");
+        x.medicament = get_untyped(j, "medicament");
+        x.monogrammatic = get_untyped(j, "monogrammatic");
+        x.nobbut = get_untyped(j, "nobbut");
+        x.notacanthidae = get_untyped(j, "Notacanthidae");
+        x.polyplacophore = get_untyped(j, "polyplacophore");
+        x.proexercise = get_untyped(j, "proexercise");
+        x.protoplast = get_untyped(j, "protoplast");
+        x.puzzling = get_untyped(j, "puzzling");
+        x.splanchnoskeleton = get_untyped(j, "splanchnoskeleton");
+        x.unloveliness = get_untyped(j, "unloveliness");
+        x.unquarantined = get_untyped(j, "unquarantined");
+        x.unrenounceable = get_untyped(j, "unrenounceable");
+    }
+
+    inline void to_json(json & j, const FlagmakingClass & x) {
+        j = json::object();
+        j["albarco"] = x.albarco;
+        j["Bunodonta"] = x.bunodonta;
+        j["hornify"] = x.hornify;
+        j["Hydrocorisae"] = x.hydrocorisae;
+        j["hypoglossus"] = x.hypoglossus;
+        j["inexpiably"] = x.inexpiably;
+        j["ingratitude"] = x.ingratitude;
+        j["ladyfly"] = x.ladyfly;
+        j["medicament"] = x.medicament;
+        j["monogrammatic"] = x.monogrammatic;
+        j["nobbut"] = x.nobbut;
+        j["Notacanthidae"] = x.notacanthidae;
+        j["polyplacophore"] = x.polyplacophore;
+        j["proexercise"] = x.proexercise;
+        j["protoplast"] = x.protoplast;
+        j["puzzling"] = x.puzzling;
+        j["splanchnoskeleton"] = x.splanchnoskeleton;
+        j["unloveliness"] = x.unloveliness;
+        j["unquarantined"] = x.unquarantined;
+        j["unrenounceable"] = x.unrenounceable;
+    }
+
+    inline void from_json(const json & j, HemocoeleClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.acrogamy = get_untyped(j, "acrogamy");
+        x.amelification = get_untyped(j, "amelification");
+        x.autobiographic = get_untyped(j, "autobiographic");
+        x.berat = get_untyped(j, "berat");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.disproportionably = get_untyped(j, "disproportionably");
+        x.erythrite = get_untyped(j, "erythrite");
+        x.graphic = get_untyped(j, "graphic");
+        x.hepatological = get_untyped(j, "hepatological");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.incommensurably = get_untyped(j, "incommensurably");
+        x.misaffirm = get_untyped(j, "misaffirm");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.pocketbook = get_untyped(j, "pocketbook");
+        x.sclerometric = get_untyped(j, "sclerometric");
+        x.stambouline = get_untyped(j, "stambouline");
+        x.stickpin = get_untyped(j, "stickpin");
+        x.tubulure = get_untyped(j, "tubulure");
+        x.undelated = get_untyped(j, "undelated");
+        x.unsalt = get_untyped(j, "unsalt");
+        x.untutelar = get_untyped(j, "untutelar");
+        x.vagrant = get_untyped(j, "vagrant");
+        x.walt = get_untyped(j, "Walt");
+    }
+
+    inline void to_json(json & j, const HemocoeleClass & x) {
+        j = json::object();
+        j["acrogamy"] = x.acrogamy;
+        j["amelification"] = x.amelification;
+        j["autobiographic"] = x.autobiographic;
+        j["berat"] = x.berat;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["disproportionably"] = x.disproportionably;
+        j["erythrite"] = x.erythrite;
+        j["graphic"] = x.graphic;
+        j["hepatological"] = x.hepatological;
+        j["homocerc"] = x.homocerc;
+        j["incommensurably"] = x.incommensurably;
+        j["misaffirm"] = x.misaffirm;
+        j["nonbookish"] = x.nonbookish;
+        j["pocketbook"] = x.pocketbook;
+        j["sclerometric"] = x.sclerometric;
+        j["stambouline"] = x.stambouline;
+        j["stickpin"] = x.stickpin;
+        j["tubulure"] = x.tubulure;
+        j["undelated"] = x.undelated;
+        j["unsalt"] = x.unsalt;
+        j["untutelar"] = x.untutelar;
+        j["vagrant"] = x.vagrant;
+        j["Walt"] = x.walt;
+    }
+
+    inline void from_json(const json & j, Interacinar& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.assapan = j.at("assapan").get<double>();
+        x.benefactorship = j.at("benefactorship").get<bool>();
+        x.triseriatim = j.at("triseriatim").get<std::string>();
+        x.tubbing = j.at("tubbing").get<int64_t>();
+        x.untrimmed = get_untyped(j, "untrimmed");
+    }
+
+    inline void to_json(json & j, const Interacinar & x) {
+        j = json::object();
+        j["assapan"] = x.assapan;
+        j["benefactorship"] = x.benefactorship;
+        j["triseriatim"] = x.triseriatim;
+        j["tubbing"] = x.tubbing;
+        j["untrimmed"] = x.untrimmed;
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.centrodesmose = j.at("centrodesmose").get<std::string>();
+        x.cerograph = j.at("cerograph").get<std::vector<CerographElement>>();
+        x.chemotherapeutics = j.at("chemotherapeutics").get<std::vector<ChemotherapeuticElement>>();
+        x.cimelia = j.at("cimelia").get<std::vector<CimeliaElement>>();
+        x.citrated = j.at("citrated").get<int64_t>();
+        x.clinodome = j.at("clinodome").get<std::vector<Clinodome>>();
+        x.coadjust = j.at("coadjust").get<std::vector<CoadjustElement>>();
+        x.consilience = j.at("consilience").get<std::vector<Consilience>>();
+        x.constructor = j.at("constructor").get<std::vector<Constructor>>();
+        x.continuative = j.at("continuative").get<std::vector<Continuative>>();
+        x.credulity = j.at("credulity").get<std::vector<CredulityElement>>();
+        x.creviced = j.at("creviced").get<std::vector<Creviced>>();
+        x.cubiculum = j.at("cubiculum").get<std::vector<std::vector<std::optional<int64_t>>>>();
+        x.deruralize = j.at("deruralize").get<std::vector<DeruralizeElement>>();
+        x.diaereses = j.at("diaereses").get<std::vector<DiaereseElement>>();
+        x.dissolution = j.at("dissolution").get<std::vector<std::optional<std::vector<nlohmann::json>>>>();
+        x.downstroke = j.at("downstroke").get<std::vector<Downstroke>>();
+        x.electrotautomerism = j.at("electrotautomerism").get<std::vector<std::optional<double>>>();
+        x.eleutheromania = j.at("eleutheromania").get<std::vector<Eleutheromania>>();
+        x.encrust = j.at("encrust").get<Encrust>();
+        x.entomoid = j.at("entomoid").get<std::vector<Entomoid>>();
+        x.epipaleolithic = j.at("epipaleolithic").get<std::vector<Epipaleolithic>>();
+        x.expropriable = j.at("expropriable").get<std::vector<Expropriable>>();
+        x.faggingly = j.at("faggingly").get<std::vector<FagginglyElement>>();
+        x.fenks = j.at("fenks").get<std::vector<FenkElement>>();
+        x.flagmaking = j.at("flagmaking").get<std::vector<FlagmakingElement>>();
+        x.fluorometer = j.at("fluorometer").get<std::vector<Fluorometer>>();
+        x.fulsome = j.at("fulsome").get<std::vector<std::optional<int64_t>>>();
+        x.fuzzy = j.at("fuzzy").get<std::vector<Fuzzy>>();
+        x.gardenwards = j.at("gardenwards").get<std::vector<Gardenward>>();
+        x.generalissimo = j.at("generalissimo").get<std::vector<Generalissimo>>();
+        x.habeas = j.at("habeas").get<std::vector<std::optional<std::map<std::string, int64_t>>>>();
+        x.hemicrystalline = j.at("hemicrystalline").get<std::vector<Hemicrystalline>>();
+        x.hemocoele = j.at("hemocoele").get<std::vector<HemocoeleElement>>();
+        x.hoister = j.at("hoister").get<std::vector<Hoister>>();
+        x.hyperpiesis = j.at("hyperpiesis").get<std::vector<Hyperpiesi>>();
+        x.hyppish = j.at("hyppish").get<std::vector<Hyppish>>();
+        x.idealizer = j.at("idealizer").get<std::vector<Idealizer>>();
+        x.incrustator = j.at("incrustator").get<std::vector<Incrustator>>();
+        x.intentiveness = j.at("intentiveness").get<std::vector<Intentiveness>>();
+        x.interacinar = j.at("interacinar").get<Interacinar>();
+        x.intercorrelation = j.at("intercorrelation").get<std::vector<std::optional<std::vector<int64_t>>>>();
+        x.jacutinga = j.at("jacutinga").get<std::vector<Jacutinga>>();
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["centrodesmose"] = x.centrodesmose;
+        j["cerograph"] = x.cerograph;
+        j["chemotherapeutics"] = x.chemotherapeutics;
+        j["cimelia"] = x.cimelia;
+        j["citrated"] = x.citrated;
+        j["clinodome"] = x.clinodome;
+        j["coadjust"] = x.coadjust;
+        j["consilience"] = x.consilience;
+        j["constructor"] = x.constructor;
+        j["continuative"] = x.continuative;
+        j["credulity"] = x.credulity;
+        j["creviced"] = x.creviced;
+        j["cubiculum"] = x.cubiculum;
+        j["deruralize"] = x.deruralize;
+        j["diaereses"] = x.diaereses;
+        j["dissolution"] = x.dissolution;
+        j["downstroke"] = x.downstroke;
+        j["electrotautomerism"] = x.electrotautomerism;
+        j["eleutheromania"] = x.eleutheromania;
+        j["encrust"] = x.encrust;
+        j["entomoid"] = x.entomoid;
+        j["epipaleolithic"] = x.epipaleolithic;
+        j["expropriable"] = x.expropriable;
+        j["faggingly"] = x.faggingly;
+        j["fenks"] = x.fenks;
+        j["flagmaking"] = x.flagmaking;
+        j["fluorometer"] = x.fluorometer;
+        j["fulsome"] = x.fulsome;
+        j["fuzzy"] = x.fuzzy;
+        j["gardenwards"] = x.gardenwards;
+        j["generalissimo"] = x.generalissimo;
+        j["habeas"] = x.habeas;
+        j["hemicrystalline"] = x.hemicrystalline;
+        j["hemocoele"] = x.hemocoele;
+        j["hoister"] = x.hoister;
+        j["hyperpiesis"] = x.hyperpiesis;
+        j["hyppish"] = x.hyppish;
+        j["idealizer"] = x.idealizer;
+        j["incrustator"] = x.incrustator;
+        j["intentiveness"] = x.intentiveness;
+        j["interacinar"] = x.interacinar;
+        j["intercorrelation"] = x.intercorrelation;
+        j["jacutinga"] = x.jacutinga;
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<quicktype::CerographClass, std::string>>::from_json(const json & j, std::variant<quicktype::CerographClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CerographClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CerographClass, std::string>>::to_json(json & j, const std::variant<quicktype::CerographClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CerographClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>>::from_json(const json & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::ChemotherapeuticClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>>::to_json(json & j, const std::variant<quicktype::ChemotherapeuticClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ChemotherapeuticClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(const json & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, const std::variant<double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoadjustClass, double>>::from_json(const json & j, std::variant<quicktype::CoadjustClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CoadjustClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoadjustClass, double>>::to_json(json & j, const std::variant<quicktype::CoadjustClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CoadjustClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>>::from_json(const json & j, std::variant<quicktype::CredulityClass, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CredulityClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>>::to_json(json & j, const std::variant<quicktype::CredulityClass, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CredulityClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>>::from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::DeruralizeClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>>::to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::DeruralizeClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::DiaereseClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::DiaereseClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::string>>::from_json(const json & j, std::variant<std::vector<json>, bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::string>>::to_json(json & j, const std::variant<std::vector<json>, bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>>::from_json(const json & j, std::variant<quicktype::CimeliaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>>::to_json(json & j, const std::variant<quicktype::CimeliaClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FagginglyClass, double>>::from_json(const json & j, std::variant<quicktype::FagginglyClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FagginglyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FagginglyClass, double>>::to_json(json & j, const std::variant<quicktype::FagginglyClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FagginglyClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FenkClass, std::string>>::from_json(const json & j, std::variant<quicktype::FenkClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::FenkClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FenkClass, std::string>>::to_json(json & j, const std::variant<quicktype::FenkClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FenkClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>>::from_json(const json & j, std::variant<bool, quicktype::FlagmakingClass, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FlagmakingClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>>::to_json(json & j, const std::variant<bool, quicktype::FlagmakingClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::FlagmakingClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::from_json(const json & j, std::variant<int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::to_json(json & j, const std::variant<int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, std::string>>::from_json(const json & j, std::variant<quicktype::CimeliaClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, std::string>>::to_json(json & j, const std::variant<quicktype::CimeliaClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::HemocoeleClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::HemocoeleClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::from_json(const json & j, std::variant<bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::to_json(json & j, const std::variant<bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>>::from_json(const json & j, std::variant<quicktype::CimeliaClass, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>>::to_json(json & j, const std::variant<quicktype::CimeliaClass, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations1.json/const-style-east-const--0048a2a7a881/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations1.json/const-style-east-const--0048a2a7a881/quicktype.hpp
new file mode 100644
index 0000000..237e851
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations1.json/const-style-east-const--0048a2a7a881/quicktype.hpp
@@ -0,0 +1,3350 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, std::shared_ptr<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(json const & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, std::optional<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(json const & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(json const & j, char const * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(json const & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    class CerographClass {
+        public:
+        CerographClass() = default;
+        virtual ~CerographClass() = default;
+
+        private:
+        nlohmann::json apotropaion;
+        nlohmann::json casuary;
+        nlohmann::json creaker;
+        nlohmann::json disqualification;
+        nlohmann::json imperatorious;
+        nlohmann::json impermeabilize;
+        nlohmann::json metastoma;
+        nlohmann::json noctidiurnal;
+        nlohmann::json nonreserve;
+        nlohmann::json ophthalmotonometry;
+        nlohmann::json pailful;
+        nlohmann::json pigfish;
+        nlohmann::json pongee;
+        nlohmann::json prosodical;
+        nlohmann::json scrofuloderm;
+        nlohmann::json storekeeping;
+        nlohmann::json therologist;
+        nlohmann::json tolowa;
+        nlohmann::json tradeful;
+        nlohmann::json unriveting;
+
+        public:
+        nlohmann::json const & get_apotropaion() const { return apotropaion; }
+        nlohmann::json & get_mutable_apotropaion() { return apotropaion; }
+        void set_apotropaion(nlohmann::json const & value) { this->apotropaion = value; }
+
+        nlohmann::json const & get_casuary() const { return casuary; }
+        nlohmann::json & get_mutable_casuary() { return casuary; }
+        void set_casuary(nlohmann::json const & value) { this->casuary = value; }
+
+        nlohmann::json const & get_creaker() const { return creaker; }
+        nlohmann::json & get_mutable_creaker() { return creaker; }
+        void set_creaker(nlohmann::json const & value) { this->creaker = value; }
+
+        nlohmann::json const & get_disqualification() const { return disqualification; }
+        nlohmann::json & get_mutable_disqualification() { return disqualification; }
+        void set_disqualification(nlohmann::json const & value) { this->disqualification = value; }
+
+        nlohmann::json const & get_imperatorious() const { return imperatorious; }
+        nlohmann::json & get_mutable_imperatorious() { return imperatorious; }
+        void set_imperatorious(nlohmann::json const & value) { this->imperatorious = value; }
+
+        nlohmann::json const & get_impermeabilize() const { return impermeabilize; }
+        nlohmann::json & get_mutable_impermeabilize() { return impermeabilize; }
+        void set_impermeabilize(nlohmann::json const & value) { this->impermeabilize = value; }
+
+        nlohmann::json const & get_metastoma() const { return metastoma; }
+        nlohmann::json & get_mutable_metastoma() { return metastoma; }
+        void set_metastoma(nlohmann::json const & value) { this->metastoma = value; }
+
+        nlohmann::json const & get_noctidiurnal() const { return noctidiurnal; }
+        nlohmann::json & get_mutable_noctidiurnal() { return noctidiurnal; }
+        void set_noctidiurnal(nlohmann::json const & value) { this->noctidiurnal = value; }
+
+        nlohmann::json const & get_nonreserve() const { return nonreserve; }
+        nlohmann::json & get_mutable_nonreserve() { return nonreserve; }
+        void set_nonreserve(nlohmann::json const & value) { this->nonreserve = value; }
+
+        nlohmann::json const & get_ophthalmotonometry() const { return ophthalmotonometry; }
+        nlohmann::json & get_mutable_ophthalmotonometry() { return ophthalmotonometry; }
+        void set_ophthalmotonometry(nlohmann::json const & value) { this->ophthalmotonometry = value; }
+
+        nlohmann::json const & get_pailful() const { return pailful; }
+        nlohmann::json & get_mutable_pailful() { return pailful; }
+        void set_pailful(nlohmann::json const & value) { this->pailful = value; }
+
+        nlohmann::json const & get_pigfish() const { return pigfish; }
+        nlohmann::json & get_mutable_pigfish() { return pigfish; }
+        void set_pigfish(nlohmann::json const & value) { this->pigfish = value; }
+
+        nlohmann::json const & get_pongee() const { return pongee; }
+        nlohmann::json & get_mutable_pongee() { return pongee; }
+        void set_pongee(nlohmann::json const & value) { this->pongee = value; }
+
+        nlohmann::json const & get_prosodical() const { return prosodical; }
+        nlohmann::json & get_mutable_prosodical() { return prosodical; }
+        void set_prosodical(nlohmann::json const & value) { this->prosodical = value; }
+
+        nlohmann::json const & get_scrofuloderm() const { return scrofuloderm; }
+        nlohmann::json & get_mutable_scrofuloderm() { return scrofuloderm; }
+        void set_scrofuloderm(nlohmann::json const & value) { this->scrofuloderm = value; }
+
+        nlohmann::json const & get_storekeeping() const { return storekeeping; }
+        nlohmann::json & get_mutable_storekeeping() { return storekeeping; }
+        void set_storekeeping(nlohmann::json const & value) { this->storekeeping = value; }
+
+        nlohmann::json const & get_therologist() const { return therologist; }
+        nlohmann::json & get_mutable_therologist() { return therologist; }
+        void set_therologist(nlohmann::json const & value) { this->therologist = value; }
+
+        nlohmann::json const & get_tolowa() const { return tolowa; }
+        nlohmann::json & get_mutable_tolowa() { return tolowa; }
+        void set_tolowa(nlohmann::json const & value) { this->tolowa = value; }
+
+        nlohmann::json const & get_tradeful() const { return tradeful; }
+        nlohmann::json & get_mutable_tradeful() { return tradeful; }
+        void set_tradeful(nlohmann::json const & value) { this->tradeful = value; }
+
+        nlohmann::json const & get_unriveting() const { return unriveting; }
+        nlohmann::json & get_mutable_unriveting() { return unriveting; }
+        void set_unriveting(nlohmann::json const & value) { this->unriveting = value; }
+    };
+
+    using CerographElement = std::optional<std::variant<CerographClass, std::string>>;
+
+    class ChemotherapeuticClass {
+        public:
+        ChemotherapeuticClass() = default;
+        virtual ~ChemotherapeuticClass() = default;
+
+        private:
+        nlohmann::json angioneurotic;
+        nlohmann::json availment;
+        nlohmann::json bladelet;
+        std::optional<double> catharticalness;
+        nlohmann::json caulis;
+        nlohmann::json chalcus;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enteradenological;
+        std::optional<bool> homocerc;
+        nlohmann::json imporosity;
+        nlohmann::json insistently;
+        nlohmann::json intraparietal;
+        nlohmann::json ivied;
+        nlohmann::json maureen;
+        nlohmann::json nonbookish;
+        nlohmann::json nostochine;
+        nlohmann::json nutcracker;
+        nlohmann::json ofttimes;
+        nlohmann::json phenocryst;
+        nlohmann::json precoincident;
+        nlohmann::json ramiferous;
+        nlohmann::json stagmometer;
+        nlohmann::json tetherball;
+        nlohmann::json unshy;
+
+        public:
+        nlohmann::json const & get_angioneurotic() const { return angioneurotic; }
+        nlohmann::json & get_mutable_angioneurotic() { return angioneurotic; }
+        void set_angioneurotic(nlohmann::json const & value) { this->angioneurotic = value; }
+
+        nlohmann::json const & get_availment() const { return availment; }
+        nlohmann::json & get_mutable_availment() { return availment; }
+        void set_availment(nlohmann::json const & value) { this->availment = value; }
+
+        nlohmann::json const & get_bladelet() const { return bladelet; }
+        nlohmann::json & get_mutable_bladelet() { return bladelet; }
+        void set_bladelet(nlohmann::json const & value) { this->bladelet = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        nlohmann::json const & get_caulis() const { return caulis; }
+        nlohmann::json & get_mutable_caulis() { return caulis; }
+        void set_caulis(nlohmann::json const & value) { this->caulis = value; }
+
+        nlohmann::json const & get_chalcus() const { return chalcus; }
+        nlohmann::json & get_mutable_chalcus() { return chalcus; }
+        void set_chalcus(nlohmann::json const & value) { this->chalcus = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_enteradenological() const { return enteradenological; }
+        nlohmann::json & get_mutable_enteradenological() { return enteradenological; }
+        void set_enteradenological(nlohmann::json const & value) { this->enteradenological = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_imporosity() const { return imporosity; }
+        nlohmann::json & get_mutable_imporosity() { return imporosity; }
+        void set_imporosity(nlohmann::json const & value) { this->imporosity = value; }
+
+        nlohmann::json const & get_insistently() const { return insistently; }
+        nlohmann::json & get_mutable_insistently() { return insistently; }
+        void set_insistently(nlohmann::json const & value) { this->insistently = value; }
+
+        nlohmann::json const & get_intraparietal() const { return intraparietal; }
+        nlohmann::json & get_mutable_intraparietal() { return intraparietal; }
+        void set_intraparietal(nlohmann::json const & value) { this->intraparietal = value; }
+
+        nlohmann::json const & get_ivied() const { return ivied; }
+        nlohmann::json & get_mutable_ivied() { return ivied; }
+        void set_ivied(nlohmann::json const & value) { this->ivied = value; }
+
+        nlohmann::json const & get_maureen() const { return maureen; }
+        nlohmann::json & get_mutable_maureen() { return maureen; }
+        void set_maureen(nlohmann::json const & value) { this->maureen = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_nostochine() const { return nostochine; }
+        nlohmann::json & get_mutable_nostochine() { return nostochine; }
+        void set_nostochine(nlohmann::json const & value) { this->nostochine = value; }
+
+        nlohmann::json const & get_nutcracker() const { return nutcracker; }
+        nlohmann::json & get_mutable_nutcracker() { return nutcracker; }
+        void set_nutcracker(nlohmann::json const & value) { this->nutcracker = value; }
+
+        nlohmann::json const & get_ofttimes() const { return ofttimes; }
+        nlohmann::json & get_mutable_ofttimes() { return ofttimes; }
+        void set_ofttimes(nlohmann::json const & value) { this->ofttimes = value; }
+
+        nlohmann::json const & get_phenocryst() const { return phenocryst; }
+        nlohmann::json & get_mutable_phenocryst() { return phenocryst; }
+        void set_phenocryst(nlohmann::json const & value) { this->phenocryst = value; }
+
+        nlohmann::json const & get_precoincident() const { return precoincident; }
+        nlohmann::json & get_mutable_precoincident() { return precoincident; }
+        void set_precoincident(nlohmann::json const & value) { this->precoincident = value; }
+
+        nlohmann::json const & get_ramiferous() const { return ramiferous; }
+        nlohmann::json & get_mutable_ramiferous() { return ramiferous; }
+        void set_ramiferous(nlohmann::json const & value) { this->ramiferous = value; }
+
+        nlohmann::json const & get_stagmometer() const { return stagmometer; }
+        nlohmann::json & get_mutable_stagmometer() { return stagmometer; }
+        void set_stagmometer(nlohmann::json const & value) { this->stagmometer = value; }
+
+        nlohmann::json const & get_tetherball() const { return tetherball; }
+        nlohmann::json & get_mutable_tetherball() { return tetherball; }
+        void set_tetherball(nlohmann::json const & value) { this->tetherball = value; }
+
+        nlohmann::json const & get_unshy() const { return unshy; }
+        nlohmann::json & get_mutable_unshy() { return unshy; }
+        void set_unshy(nlohmann::json const & value) { this->unshy = value; }
+    };
+
+    using ChemotherapeuticElement = std::variant<ChemotherapeuticClass, int64_t>;
+
+    class CimeliaClass {
+        public:
+        CimeliaClass() = default;
+        virtual ~CimeliaClass() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        double const & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(double const & value) { this->catharticalness = value; }
+
+        int64_t const & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(int64_t const & value) { this->chirotherium = value; }
+
+        std::string const & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::string const & value) { this->disdiapason = value; }
+
+        bool const & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(bool const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+    };
+
+    using CimeliaElement = std::optional<std::variant<std::vector<int64_t>, CimeliaClass>>;
+
+    using Clinodome = std::variant<double, std::string>;
+
+    class CoadjustClass {
+        public:
+        CoadjustClass() = default;
+        virtual ~CoadjustClass() = default;
+
+        private:
+        nlohmann::json amidosulphonal;
+        nlohmann::json benny;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json ensnare;
+        std::optional<bool> homocerc;
+        nlohmann::json hybridizer;
+        nlohmann::json leastwise;
+        nlohmann::json lof;
+        nlohmann::json monkhood;
+        nlohmann::json netherlandish;
+        nlohmann::json nonbookish;
+        nlohmann::json peonism;
+        nlohmann::json phonelescope;
+        nlohmann::json porphyrogeniture;
+        nlohmann::json preindemnify;
+        nlohmann::json rosal;
+        nlohmann::json scalenous;
+        nlohmann::json scopine;
+        nlohmann::json sedaceae;
+        nlohmann::json suberinize;
+        nlohmann::json symbiot;
+        nlohmann::json tablefellow;
+        nlohmann::json unchargeable;
+
+        public:
+        nlohmann::json const & get_amidosulphonal() const { return amidosulphonal; }
+        nlohmann::json & get_mutable_amidosulphonal() { return amidosulphonal; }
+        void set_amidosulphonal(nlohmann::json const & value) { this->amidosulphonal = value; }
+
+        nlohmann::json const & get_benny() const { return benny; }
+        nlohmann::json & get_mutable_benny() { return benny; }
+        void set_benny(nlohmann::json const & value) { this->benny = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_ensnare() const { return ensnare; }
+        nlohmann::json & get_mutable_ensnare() { return ensnare; }
+        void set_ensnare(nlohmann::json const & value) { this->ensnare = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_hybridizer() const { return hybridizer; }
+        nlohmann::json & get_mutable_hybridizer() { return hybridizer; }
+        void set_hybridizer(nlohmann::json const & value) { this->hybridizer = value; }
+
+        nlohmann::json const & get_leastwise() const { return leastwise; }
+        nlohmann::json & get_mutable_leastwise() { return leastwise; }
+        void set_leastwise(nlohmann::json const & value) { this->leastwise = value; }
+
+        nlohmann::json const & get_lof() const { return lof; }
+        nlohmann::json & get_mutable_lof() { return lof; }
+        void set_lof(nlohmann::json const & value) { this->lof = value; }
+
+        nlohmann::json const & get_monkhood() const { return monkhood; }
+        nlohmann::json & get_mutable_monkhood() { return monkhood; }
+        void set_monkhood(nlohmann::json const & value) { this->monkhood = value; }
+
+        nlohmann::json const & get_netherlandish() const { return netherlandish; }
+        nlohmann::json & get_mutable_netherlandish() { return netherlandish; }
+        void set_netherlandish(nlohmann::json const & value) { this->netherlandish = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_peonism() const { return peonism; }
+        nlohmann::json & get_mutable_peonism() { return peonism; }
+        void set_peonism(nlohmann::json const & value) { this->peonism = value; }
+
+        nlohmann::json const & get_phonelescope() const { return phonelescope; }
+        nlohmann::json & get_mutable_phonelescope() { return phonelescope; }
+        void set_phonelescope(nlohmann::json const & value) { this->phonelescope = value; }
+
+        nlohmann::json const & get_porphyrogeniture() const { return porphyrogeniture; }
+        nlohmann::json & get_mutable_porphyrogeniture() { return porphyrogeniture; }
+        void set_porphyrogeniture(nlohmann::json const & value) { this->porphyrogeniture = value; }
+
+        nlohmann::json const & get_preindemnify() const { return preindemnify; }
+        nlohmann::json & get_mutable_preindemnify() { return preindemnify; }
+        void set_preindemnify(nlohmann::json const & value) { this->preindemnify = value; }
+
+        nlohmann::json const & get_rosal() const { return rosal; }
+        nlohmann::json & get_mutable_rosal() { return rosal; }
+        void set_rosal(nlohmann::json const & value) { this->rosal = value; }
+
+        nlohmann::json const & get_scalenous() const { return scalenous; }
+        nlohmann::json & get_mutable_scalenous() { return scalenous; }
+        void set_scalenous(nlohmann::json const & value) { this->scalenous = value; }
+
+        nlohmann::json const & get_scopine() const { return scopine; }
+        nlohmann::json & get_mutable_scopine() { return scopine; }
+        void set_scopine(nlohmann::json const & value) { this->scopine = value; }
+
+        nlohmann::json const & get_sedaceae() const { return sedaceae; }
+        nlohmann::json & get_mutable_sedaceae() { return sedaceae; }
+        void set_sedaceae(nlohmann::json const & value) { this->sedaceae = value; }
+
+        nlohmann::json const & get_suberinize() const { return suberinize; }
+        nlohmann::json & get_mutable_suberinize() { return suberinize; }
+        void set_suberinize(nlohmann::json const & value) { this->suberinize = value; }
+
+        nlohmann::json const & get_symbiot() const { return symbiot; }
+        nlohmann::json & get_mutable_symbiot() { return symbiot; }
+        void set_symbiot(nlohmann::json const & value) { this->symbiot = value; }
+
+        nlohmann::json const & get_tablefellow() const { return tablefellow; }
+        nlohmann::json & get_mutable_tablefellow() { return tablefellow; }
+        void set_tablefellow(nlohmann::json const & value) { this->tablefellow = value; }
+
+        nlohmann::json const & get_unchargeable() const { return unchargeable; }
+        nlohmann::json & get_mutable_unchargeable() { return unchargeable; }
+        void set_unchargeable(nlohmann::json const & value) { this->unchargeable = value; }
+    };
+
+    using CoadjustElement = std::variant<CoadjustClass, double>;
+
+    using Consilience = std::variant<double, std::map<std::string, int64_t>>;
+
+    using Constructor = std::variant<bool, std::map<std::string, std::optional<int64_t>>>;
+
+    using Continuative = std::variant<std::map<std::string, int64_t>, std::string>;
+
+    class CredulityClass {
+        public:
+        CredulityClass() = default;
+        virtual ~CredulityClass() = default;
+
+        private:
+        nlohmann::json ammonolytic;
+        nlohmann::json bushmaster;
+        nlohmann::json considering;
+        nlohmann::json consuetudinary;
+        nlohmann::json embarras;
+        nlohmann::json fineness;
+        nlohmann::json flaithship;
+        nlohmann::json flavia;
+        nlohmann::json gruffly;
+        nlohmann::json hedychium;
+        nlohmann::json leadwort;
+        nlohmann::json overseriously;
+        nlohmann::json parabola;
+        nlohmann::json pectinatodenticulate;
+        nlohmann::json popean;
+        nlohmann::json pornocrat;
+        nlohmann::json quadrisect;
+        nlohmann::json seriality;
+        nlohmann::json vamphorn;
+        nlohmann::json wharp;
+
+        public:
+        nlohmann::json const & get_ammonolytic() const { return ammonolytic; }
+        nlohmann::json & get_mutable_ammonolytic() { return ammonolytic; }
+        void set_ammonolytic(nlohmann::json const & value) { this->ammonolytic = value; }
+
+        nlohmann::json const & get_bushmaster() const { return bushmaster; }
+        nlohmann::json & get_mutable_bushmaster() { return bushmaster; }
+        void set_bushmaster(nlohmann::json const & value) { this->bushmaster = value; }
+
+        nlohmann::json const & get_considering() const { return considering; }
+        nlohmann::json & get_mutable_considering() { return considering; }
+        void set_considering(nlohmann::json const & value) { this->considering = value; }
+
+        nlohmann::json const & get_consuetudinary() const { return consuetudinary; }
+        nlohmann::json & get_mutable_consuetudinary() { return consuetudinary; }
+        void set_consuetudinary(nlohmann::json const & value) { this->consuetudinary = value; }
+
+        nlohmann::json const & get_embarras() const { return embarras; }
+        nlohmann::json & get_mutable_embarras() { return embarras; }
+        void set_embarras(nlohmann::json const & value) { this->embarras = value; }
+
+        nlohmann::json const & get_fineness() const { return fineness; }
+        nlohmann::json & get_mutable_fineness() { return fineness; }
+        void set_fineness(nlohmann::json const & value) { this->fineness = value; }
+
+        nlohmann::json const & get_flaithship() const { return flaithship; }
+        nlohmann::json & get_mutable_flaithship() { return flaithship; }
+        void set_flaithship(nlohmann::json const & value) { this->flaithship = value; }
+
+        nlohmann::json const & get_flavia() const { return flavia; }
+        nlohmann::json & get_mutable_flavia() { return flavia; }
+        void set_flavia(nlohmann::json const & value) { this->flavia = value; }
+
+        nlohmann::json const & get_gruffly() const { return gruffly; }
+        nlohmann::json & get_mutable_gruffly() { return gruffly; }
+        void set_gruffly(nlohmann::json const & value) { this->gruffly = value; }
+
+        nlohmann::json const & get_hedychium() const { return hedychium; }
+        nlohmann::json & get_mutable_hedychium() { return hedychium; }
+        void set_hedychium(nlohmann::json const & value) { this->hedychium = value; }
+
+        nlohmann::json const & get_leadwort() const { return leadwort; }
+        nlohmann::json & get_mutable_leadwort() { return leadwort; }
+        void set_leadwort(nlohmann::json const & value) { this->leadwort = value; }
+
+        nlohmann::json const & get_overseriously() const { return overseriously; }
+        nlohmann::json & get_mutable_overseriously() { return overseriously; }
+        void set_overseriously(nlohmann::json const & value) { this->overseriously = value; }
+
+        nlohmann::json const & get_parabola() const { return parabola; }
+        nlohmann::json & get_mutable_parabola() { return parabola; }
+        void set_parabola(nlohmann::json const & value) { this->parabola = value; }
+
+        nlohmann::json const & get_pectinatodenticulate() const { return pectinatodenticulate; }
+        nlohmann::json & get_mutable_pectinatodenticulate() { return pectinatodenticulate; }
+        void set_pectinatodenticulate(nlohmann::json const & value) { this->pectinatodenticulate = value; }
+
+        nlohmann::json const & get_popean() const { return popean; }
+        nlohmann::json & get_mutable_popean() { return popean; }
+        void set_popean(nlohmann::json const & value) { this->popean = value; }
+
+        nlohmann::json const & get_pornocrat() const { return pornocrat; }
+        nlohmann::json & get_mutable_pornocrat() { return pornocrat; }
+        void set_pornocrat(nlohmann::json const & value) { this->pornocrat = value; }
+
+        nlohmann::json const & get_quadrisect() const { return quadrisect; }
+        nlohmann::json & get_mutable_quadrisect() { return quadrisect; }
+        void set_quadrisect(nlohmann::json const & value) { this->quadrisect = value; }
+
+        nlohmann::json const & get_seriality() const { return seriality; }
+        nlohmann::json & get_mutable_seriality() { return seriality; }
+        void set_seriality(nlohmann::json const & value) { this->seriality = value; }
+
+        nlohmann::json const & get_vamphorn() const { return vamphorn; }
+        nlohmann::json & get_mutable_vamphorn() { return vamphorn; }
+        void set_vamphorn(nlohmann::json const & value) { this->vamphorn = value; }
+
+        nlohmann::json const & get_wharp() const { return wharp; }
+        nlohmann::json & get_mutable_wharp() { return wharp; }
+        void set_wharp(nlohmann::json const & value) { this->wharp = value; }
+    };
+
+    using CredulityElement = std::variant<CredulityClass, int64_t, std::string>;
+
+    using Creviced = std::variant<bool, std::map<std::string, int64_t>, std::string>;
+
+    class DeruralizeClass {
+        public:
+        DeruralizeClass() = default;
+        virtual ~DeruralizeClass() = default;
+
+        private:
+        nlohmann::json bockerel;
+        nlohmann::json boulder;
+        nlohmann::json churrus;
+        nlohmann::json counterdigged;
+        nlohmann::json dialogite;
+        nlohmann::json digenic;
+        nlohmann::json dunbird;
+        nlohmann::json ergatogyne;
+        nlohmann::json fiendful;
+        nlohmann::json jackrod;
+        nlohmann::json jehovistic;
+        nlohmann::json paninean;
+        nlohmann::json panther;
+        nlohmann::json placentigerous;
+        nlohmann::json romney;
+        nlohmann::json sparm;
+        nlohmann::json tocsin;
+        nlohmann::json unnicked;
+        nlohmann::json unstavable;
+        nlohmann::json windfirm;
+
+        public:
+        nlohmann::json const & get_bockerel() const { return bockerel; }
+        nlohmann::json & get_mutable_bockerel() { return bockerel; }
+        void set_bockerel(nlohmann::json const & value) { this->bockerel = value; }
+
+        nlohmann::json const & get_boulder() const { return boulder; }
+        nlohmann::json & get_mutable_boulder() { return boulder; }
+        void set_boulder(nlohmann::json const & value) { this->boulder = value; }
+
+        nlohmann::json const & get_churrus() const { return churrus; }
+        nlohmann::json & get_mutable_churrus() { return churrus; }
+        void set_churrus(nlohmann::json const & value) { this->churrus = value; }
+
+        nlohmann::json const & get_counterdigged() const { return counterdigged; }
+        nlohmann::json & get_mutable_counterdigged() { return counterdigged; }
+        void set_counterdigged(nlohmann::json const & value) { this->counterdigged = value; }
+
+        nlohmann::json const & get_dialogite() const { return dialogite; }
+        nlohmann::json & get_mutable_dialogite() { return dialogite; }
+        void set_dialogite(nlohmann::json const & value) { this->dialogite = value; }
+
+        nlohmann::json const & get_digenic() const { return digenic; }
+        nlohmann::json & get_mutable_digenic() { return digenic; }
+        void set_digenic(nlohmann::json const & value) { this->digenic = value; }
+
+        nlohmann::json const & get_dunbird() const { return dunbird; }
+        nlohmann::json & get_mutable_dunbird() { return dunbird; }
+        void set_dunbird(nlohmann::json const & value) { this->dunbird = value; }
+
+        nlohmann::json const & get_ergatogyne() const { return ergatogyne; }
+        nlohmann::json & get_mutable_ergatogyne() { return ergatogyne; }
+        void set_ergatogyne(nlohmann::json const & value) { this->ergatogyne = value; }
+
+        nlohmann::json const & get_fiendful() const { return fiendful; }
+        nlohmann::json & get_mutable_fiendful() { return fiendful; }
+        void set_fiendful(nlohmann::json const & value) { this->fiendful = value; }
+
+        nlohmann::json const & get_jackrod() const { return jackrod; }
+        nlohmann::json & get_mutable_jackrod() { return jackrod; }
+        void set_jackrod(nlohmann::json const & value) { this->jackrod = value; }
+
+        nlohmann::json const & get_jehovistic() const { return jehovistic; }
+        nlohmann::json & get_mutable_jehovistic() { return jehovistic; }
+        void set_jehovistic(nlohmann::json const & value) { this->jehovistic = value; }
+
+        nlohmann::json const & get_paninean() const { return paninean; }
+        nlohmann::json & get_mutable_paninean() { return paninean; }
+        void set_paninean(nlohmann::json const & value) { this->paninean = value; }
+
+        nlohmann::json const & get_panther() const { return panther; }
+        nlohmann::json & get_mutable_panther() { return panther; }
+        void set_panther(nlohmann::json const & value) { this->panther = value; }
+
+        nlohmann::json const & get_placentigerous() const { return placentigerous; }
+        nlohmann::json & get_mutable_placentigerous() { return placentigerous; }
+        void set_placentigerous(nlohmann::json const & value) { this->placentigerous = value; }
+
+        nlohmann::json const & get_romney() const { return romney; }
+        nlohmann::json & get_mutable_romney() { return romney; }
+        void set_romney(nlohmann::json const & value) { this->romney = value; }
+
+        nlohmann::json const & get_sparm() const { return sparm; }
+        nlohmann::json & get_mutable_sparm() { return sparm; }
+        void set_sparm(nlohmann::json const & value) { this->sparm = value; }
+
+        nlohmann::json const & get_tocsin() const { return tocsin; }
+        nlohmann::json & get_mutable_tocsin() { return tocsin; }
+        void set_tocsin(nlohmann::json const & value) { this->tocsin = value; }
+
+        nlohmann::json const & get_unnicked() const { return unnicked; }
+        nlohmann::json & get_mutable_unnicked() { return unnicked; }
+        void set_unnicked(nlohmann::json const & value) { this->unnicked = value; }
+
+        nlohmann::json const & get_unstavable() const { return unstavable; }
+        nlohmann::json & get_mutable_unstavable() { return unstavable; }
+        void set_unstavable(nlohmann::json const & value) { this->unstavable = value; }
+
+        nlohmann::json const & get_windfirm() const { return windfirm; }
+        nlohmann::json & get_mutable_windfirm() { return windfirm; }
+        void set_windfirm(nlohmann::json const & value) { this->windfirm = value; }
+    };
+
+    using DeruralizeElement = std::variant<std::vector<nlohmann::json>, bool, DeruralizeClass>;
+
+    class DiaereseClass {
+        public:
+        DiaereseClass() = default;
+        virtual ~DiaereseClass() = default;
+
+        private:
+        nlohmann::json amoreuxia;
+        nlohmann::json ani;
+        nlohmann::json bernicle;
+        nlohmann::json blackwasher;
+        nlohmann::json blowhard;
+        nlohmann::json broma;
+        nlohmann::json closecross;
+        nlohmann::json congregationalism;
+        nlohmann::json grayly;
+        nlohmann::json historically;
+        nlohmann::json hoast;
+        nlohmann::json irretentive;
+        nlohmann::json parcener;
+        nlohmann::json pedder;
+        nlohmann::json pseudoanatomic;
+        nlohmann::json rhizocarpian;
+        nlohmann::json samel;
+        nlohmann::json silker;
+        nlohmann::json subdentated;
+        nlohmann::json subobscure;
+
+        public:
+        nlohmann::json const & get_amoreuxia() const { return amoreuxia; }
+        nlohmann::json & get_mutable_amoreuxia() { return amoreuxia; }
+        void set_amoreuxia(nlohmann::json const & value) { this->amoreuxia = value; }
+
+        nlohmann::json const & get_ani() const { return ani; }
+        nlohmann::json & get_mutable_ani() { return ani; }
+        void set_ani(nlohmann::json const & value) { this->ani = value; }
+
+        nlohmann::json const & get_bernicle() const { return bernicle; }
+        nlohmann::json & get_mutable_bernicle() { return bernicle; }
+        void set_bernicle(nlohmann::json const & value) { this->bernicle = value; }
+
+        nlohmann::json const & get_blackwasher() const { return blackwasher; }
+        nlohmann::json & get_mutable_blackwasher() { return blackwasher; }
+        void set_blackwasher(nlohmann::json const & value) { this->blackwasher = value; }
+
+        nlohmann::json const & get_blowhard() const { return blowhard; }
+        nlohmann::json & get_mutable_blowhard() { return blowhard; }
+        void set_blowhard(nlohmann::json const & value) { this->blowhard = value; }
+
+        nlohmann::json const & get_broma() const { return broma; }
+        nlohmann::json & get_mutable_broma() { return broma; }
+        void set_broma(nlohmann::json const & value) { this->broma = value; }
+
+        nlohmann::json const & get_closecross() const { return closecross; }
+        nlohmann::json & get_mutable_closecross() { return closecross; }
+        void set_closecross(nlohmann::json const & value) { this->closecross = value; }
+
+        nlohmann::json const & get_congregationalism() const { return congregationalism; }
+        nlohmann::json & get_mutable_congregationalism() { return congregationalism; }
+        void set_congregationalism(nlohmann::json const & value) { this->congregationalism = value; }
+
+        nlohmann::json const & get_grayly() const { return grayly; }
+        nlohmann::json & get_mutable_grayly() { return grayly; }
+        void set_grayly(nlohmann::json const & value) { this->grayly = value; }
+
+        nlohmann::json const & get_historically() const { return historically; }
+        nlohmann::json & get_mutable_historically() { return historically; }
+        void set_historically(nlohmann::json const & value) { this->historically = value; }
+
+        nlohmann::json const & get_hoast() const { return hoast; }
+        nlohmann::json & get_mutable_hoast() { return hoast; }
+        void set_hoast(nlohmann::json const & value) { this->hoast = value; }
+
+        nlohmann::json const & get_irretentive() const { return irretentive; }
+        nlohmann::json & get_mutable_irretentive() { return irretentive; }
+        void set_irretentive(nlohmann::json const & value) { this->irretentive = value; }
+
+        nlohmann::json const & get_parcener() const { return parcener; }
+        nlohmann::json & get_mutable_parcener() { return parcener; }
+        void set_parcener(nlohmann::json const & value) { this->parcener = value; }
+
+        nlohmann::json const & get_pedder() const { return pedder; }
+        nlohmann::json & get_mutable_pedder() { return pedder; }
+        void set_pedder(nlohmann::json const & value) { this->pedder = value; }
+
+        nlohmann::json const & get_pseudoanatomic() const { return pseudoanatomic; }
+        nlohmann::json & get_mutable_pseudoanatomic() { return pseudoanatomic; }
+        void set_pseudoanatomic(nlohmann::json const & value) { this->pseudoanatomic = value; }
+
+        nlohmann::json const & get_rhizocarpian() const { return rhizocarpian; }
+        nlohmann::json & get_mutable_rhizocarpian() { return rhizocarpian; }
+        void set_rhizocarpian(nlohmann::json const & value) { this->rhizocarpian = value; }
+
+        nlohmann::json const & get_samel() const { return samel; }
+        nlohmann::json & get_mutable_samel() { return samel; }
+        void set_samel(nlohmann::json const & value) { this->samel = value; }
+
+        nlohmann::json const & get_silker() const { return silker; }
+        nlohmann::json & get_mutable_silker() { return silker; }
+        void set_silker(nlohmann::json const & value) { this->silker = value; }
+
+        nlohmann::json const & get_subdentated() const { return subdentated; }
+        nlohmann::json & get_mutable_subdentated() { return subdentated; }
+        void set_subdentated(nlohmann::json const & value) { this->subdentated = value; }
+
+        nlohmann::json const & get_subobscure() const { return subobscure; }
+        nlohmann::json & get_mutable_subobscure() { return subobscure; }
+        void set_subobscure(nlohmann::json const & value) { this->subobscure = value; }
+    };
+
+    using DiaereseElement = std::variant<std::vector<int64_t>, bool, DiaereseClass>;
+
+    using Downstroke = std::variant<std::vector<nlohmann::json>, bool, std::string>;
+
+    using Eleutheromania = std::variant<double, std::map<std::string, int64_t>, std::string>;
+
+    class Encrust {
+        public:
+        Encrust() = default;
+        virtual ~Encrust() = default;
+
+        private:
+        nlohmann::json comradely;
+        nlohmann::json diacanthous;
+        nlohmann::json feminineness;
+        nlohmann::json gossamered;
+        nlohmann::json hibernia;
+        nlohmann::json hibiscus;
+        nlohmann::json lepidosauria;
+        nlohmann::json lollingly;
+        nlohmann::json manager;
+        nlohmann::json mechanic;
+        nlohmann::json overminuteness;
+        nlohmann::json papelonne;
+        nlohmann::json plebification;
+        nlohmann::json pugmiller;
+        nlohmann::json recoveror;
+        nlohmann::json spermatoblastic;
+        nlohmann::json syllidae;
+        nlohmann::json ungyved;
+        nlohmann::json whirlabout;
+        nlohmann::json woodenware;
+
+        public:
+        nlohmann::json const & get_comradely() const { return comradely; }
+        nlohmann::json & get_mutable_comradely() { return comradely; }
+        void set_comradely(nlohmann::json const & value) { this->comradely = value; }
+
+        nlohmann::json const & get_diacanthous() const { return diacanthous; }
+        nlohmann::json & get_mutable_diacanthous() { return diacanthous; }
+        void set_diacanthous(nlohmann::json const & value) { this->diacanthous = value; }
+
+        nlohmann::json const & get_feminineness() const { return feminineness; }
+        nlohmann::json & get_mutable_feminineness() { return feminineness; }
+        void set_feminineness(nlohmann::json const & value) { this->feminineness = value; }
+
+        nlohmann::json const & get_gossamered() const { return gossamered; }
+        nlohmann::json & get_mutable_gossamered() { return gossamered; }
+        void set_gossamered(nlohmann::json const & value) { this->gossamered = value; }
+
+        nlohmann::json const & get_hibernia() const { return hibernia; }
+        nlohmann::json & get_mutable_hibernia() { return hibernia; }
+        void set_hibernia(nlohmann::json const & value) { this->hibernia = value; }
+
+        nlohmann::json const & get_hibiscus() const { return hibiscus; }
+        nlohmann::json & get_mutable_hibiscus() { return hibiscus; }
+        void set_hibiscus(nlohmann::json const & value) { this->hibiscus = value; }
+
+        nlohmann::json const & get_lepidosauria() const { return lepidosauria; }
+        nlohmann::json & get_mutable_lepidosauria() { return lepidosauria; }
+        void set_lepidosauria(nlohmann::json const & value) { this->lepidosauria = value; }
+
+        nlohmann::json const & get_lollingly() const { return lollingly; }
+        nlohmann::json & get_mutable_lollingly() { return lollingly; }
+        void set_lollingly(nlohmann::json const & value) { this->lollingly = value; }
+
+        nlohmann::json const & get_manager() const { return manager; }
+        nlohmann::json & get_mutable_manager() { return manager; }
+        void set_manager(nlohmann::json const & value) { this->manager = value; }
+
+        nlohmann::json const & get_mechanic() const { return mechanic; }
+        nlohmann::json & get_mutable_mechanic() { return mechanic; }
+        void set_mechanic(nlohmann::json const & value) { this->mechanic = value; }
+
+        nlohmann::json const & get_overminuteness() const { return overminuteness; }
+        nlohmann::json & get_mutable_overminuteness() { return overminuteness; }
+        void set_overminuteness(nlohmann::json const & value) { this->overminuteness = value; }
+
+        nlohmann::json const & get_papelonne() const { return papelonne; }
+        nlohmann::json & get_mutable_papelonne() { return papelonne; }
+        void set_papelonne(nlohmann::json const & value) { this->papelonne = value; }
+
+        nlohmann::json const & get_plebification() const { return plebification; }
+        nlohmann::json & get_mutable_plebification() { return plebification; }
+        void set_plebification(nlohmann::json const & value) { this->plebification = value; }
+
+        nlohmann::json const & get_pugmiller() const { return pugmiller; }
+        nlohmann::json & get_mutable_pugmiller() { return pugmiller; }
+        void set_pugmiller(nlohmann::json const & value) { this->pugmiller = value; }
+
+        nlohmann::json const & get_recoveror() const { return recoveror; }
+        nlohmann::json & get_mutable_recoveror() { return recoveror; }
+        void set_recoveror(nlohmann::json const & value) { this->recoveror = value; }
+
+        nlohmann::json const & get_spermatoblastic() const { return spermatoblastic; }
+        nlohmann::json & get_mutable_spermatoblastic() { return spermatoblastic; }
+        void set_spermatoblastic(nlohmann::json const & value) { this->spermatoblastic = value; }
+
+        nlohmann::json const & get_syllidae() const { return syllidae; }
+        nlohmann::json & get_mutable_syllidae() { return syllidae; }
+        void set_syllidae(nlohmann::json const & value) { this->syllidae = value; }
+
+        nlohmann::json const & get_ungyved() const { return ungyved; }
+        nlohmann::json & get_mutable_ungyved() { return ungyved; }
+        void set_ungyved(nlohmann::json const & value) { this->ungyved = value; }
+
+        nlohmann::json const & get_whirlabout() const { return whirlabout; }
+        nlohmann::json & get_mutable_whirlabout() { return whirlabout; }
+        void set_whirlabout(nlohmann::json const & value) { this->whirlabout = value; }
+
+        nlohmann::json const & get_woodenware() const { return woodenware; }
+        nlohmann::json & get_mutable_woodenware() { return woodenware; }
+        void set_woodenware(nlohmann::json const & value) { this->woodenware = value; }
+    };
+
+    using Entomoid = std::variant<CimeliaClass, int64_t>;
+
+    using Epipaleolithic = std::variant<std::vector<int64_t>, double>;
+
+    using Expropriable = std::variant<std::vector<nlohmann::json>, CimeliaClass, double>;
+
+    class FagginglyClass {
+        public:
+        FagginglyClass() = default;
+        virtual ~FagginglyClass() = default;
+
+        private:
+        nlohmann::json abranchian;
+        nlohmann::json aculeiform;
+        nlohmann::json adiaphoristic;
+        nlohmann::json adoptionism;
+        nlohmann::json anglic;
+        nlohmann::json antrotomy;
+        nlohmann::json coerciveness;
+        nlohmann::json decorist;
+        nlohmann::json duckhood;
+        nlohmann::json heteromeri;
+        nlohmann::json hypochnose;
+        nlohmann::json lochage;
+        nlohmann::json melee;
+        nlohmann::json nonconformitant;
+        nlohmann::json poinsettia;
+        nlohmann::json putatively;
+        nlohmann::json semivolatile;
+        nlohmann::json soleas;
+        nlohmann::json unfastenable;
+        nlohmann::json unmillinered;
+
+        public:
+        nlohmann::json const & get_abranchian() const { return abranchian; }
+        nlohmann::json & get_mutable_abranchian() { return abranchian; }
+        void set_abranchian(nlohmann::json const & value) { this->abranchian = value; }
+
+        nlohmann::json const & get_aculeiform() const { return aculeiform; }
+        nlohmann::json & get_mutable_aculeiform() { return aculeiform; }
+        void set_aculeiform(nlohmann::json const & value) { this->aculeiform = value; }
+
+        nlohmann::json const & get_adiaphoristic() const { return adiaphoristic; }
+        nlohmann::json & get_mutable_adiaphoristic() { return adiaphoristic; }
+        void set_adiaphoristic(nlohmann::json const & value) { this->adiaphoristic = value; }
+
+        nlohmann::json const & get_adoptionism() const { return adoptionism; }
+        nlohmann::json & get_mutable_adoptionism() { return adoptionism; }
+        void set_adoptionism(nlohmann::json const & value) { this->adoptionism = value; }
+
+        nlohmann::json const & get_anglic() const { return anglic; }
+        nlohmann::json & get_mutable_anglic() { return anglic; }
+        void set_anglic(nlohmann::json const & value) { this->anglic = value; }
+
+        nlohmann::json const & get_antrotomy() const { return antrotomy; }
+        nlohmann::json & get_mutable_antrotomy() { return antrotomy; }
+        void set_antrotomy(nlohmann::json const & value) { this->antrotomy = value; }
+
+        nlohmann::json const & get_coerciveness() const { return coerciveness; }
+        nlohmann::json & get_mutable_coerciveness() { return coerciveness; }
+        void set_coerciveness(nlohmann::json const & value) { this->coerciveness = value; }
+
+        nlohmann::json const & get_decorist() const { return decorist; }
+        nlohmann::json & get_mutable_decorist() { return decorist; }
+        void set_decorist(nlohmann::json const & value) { this->decorist = value; }
+
+        nlohmann::json const & get_duckhood() const { return duckhood; }
+        nlohmann::json & get_mutable_duckhood() { return duckhood; }
+        void set_duckhood(nlohmann::json const & value) { this->duckhood = value; }
+
+        nlohmann::json const & get_heteromeri() const { return heteromeri; }
+        nlohmann::json & get_mutable_heteromeri() { return heteromeri; }
+        void set_heteromeri(nlohmann::json const & value) { this->heteromeri = value; }
+
+        nlohmann::json const & get_hypochnose() const { return hypochnose; }
+        nlohmann::json & get_mutable_hypochnose() { return hypochnose; }
+        void set_hypochnose(nlohmann::json const & value) { this->hypochnose = value; }
+
+        nlohmann::json const & get_lochage() const { return lochage; }
+        nlohmann::json & get_mutable_lochage() { return lochage; }
+        void set_lochage(nlohmann::json const & value) { this->lochage = value; }
+
+        nlohmann::json const & get_melee() const { return melee; }
+        nlohmann::json & get_mutable_melee() { return melee; }
+        void set_melee(nlohmann::json const & value) { this->melee = value; }
+
+        nlohmann::json const & get_nonconformitant() const { return nonconformitant; }
+        nlohmann::json & get_mutable_nonconformitant() { return nonconformitant; }
+        void set_nonconformitant(nlohmann::json const & value) { this->nonconformitant = value; }
+
+        nlohmann::json const & get_poinsettia() const { return poinsettia; }
+        nlohmann::json & get_mutable_poinsettia() { return poinsettia; }
+        void set_poinsettia(nlohmann::json const & value) { this->poinsettia = value; }
+
+        nlohmann::json const & get_putatively() const { return putatively; }
+        nlohmann::json & get_mutable_putatively() { return putatively; }
+        void set_putatively(nlohmann::json const & value) { this->putatively = value; }
+
+        nlohmann::json const & get_semivolatile() const { return semivolatile; }
+        nlohmann::json & get_mutable_semivolatile() { return semivolatile; }
+        void set_semivolatile(nlohmann::json const & value) { this->semivolatile = value; }
+
+        nlohmann::json const & get_soleas() const { return soleas; }
+        nlohmann::json & get_mutable_soleas() { return soleas; }
+        void set_soleas(nlohmann::json const & value) { this->soleas = value; }
+
+        nlohmann::json const & get_unfastenable() const { return unfastenable; }
+        nlohmann::json & get_mutable_unfastenable() { return unfastenable; }
+        void set_unfastenable(nlohmann::json const & value) { this->unfastenable = value; }
+
+        nlohmann::json const & get_unmillinered() const { return unmillinered; }
+        nlohmann::json & get_mutable_unmillinered() { return unmillinered; }
+        void set_unmillinered(nlohmann::json const & value) { this->unmillinered = value; }
+    };
+
+    using FagginglyElement = std::variant<FagginglyClass, double>;
+
+    class FenkClass {
+        public:
+        FenkClass() = default;
+        virtual ~FenkClass() = default;
+
+        private:
+        nlohmann::json apoise;
+        nlohmann::json astronomize;
+        nlohmann::json cockhorse;
+        nlohmann::json copular;
+        nlohmann::json dagomba;
+        nlohmann::json draffy;
+        nlohmann::json foreigner;
+        nlohmann::json guyandot;
+        nlohmann::json neurogliosis;
+        nlohmann::json osmious;
+        nlohmann::json palpitate;
+        nlohmann::json rebukeable;
+        nlohmann::json reinwardtia;
+        nlohmann::json reservatory;
+        nlohmann::json scalt;
+        nlohmann::json scripturalize;
+        nlohmann::json tintometer;
+        nlohmann::json tritoness;
+        nlohmann::json undergrade;
+        nlohmann::json undermountain;
+
+        public:
+        nlohmann::json const & get_apoise() const { return apoise; }
+        nlohmann::json & get_mutable_apoise() { return apoise; }
+        void set_apoise(nlohmann::json const & value) { this->apoise = value; }
+
+        nlohmann::json const & get_astronomize() const { return astronomize; }
+        nlohmann::json & get_mutable_astronomize() { return astronomize; }
+        void set_astronomize(nlohmann::json const & value) { this->astronomize = value; }
+
+        nlohmann::json const & get_cockhorse() const { return cockhorse; }
+        nlohmann::json & get_mutable_cockhorse() { return cockhorse; }
+        void set_cockhorse(nlohmann::json const & value) { this->cockhorse = value; }
+
+        nlohmann::json const & get_copular() const { return copular; }
+        nlohmann::json & get_mutable_copular() { return copular; }
+        void set_copular(nlohmann::json const & value) { this->copular = value; }
+
+        nlohmann::json const & get_dagomba() const { return dagomba; }
+        nlohmann::json & get_mutable_dagomba() { return dagomba; }
+        void set_dagomba(nlohmann::json const & value) { this->dagomba = value; }
+
+        nlohmann::json const & get_draffy() const { return draffy; }
+        nlohmann::json & get_mutable_draffy() { return draffy; }
+        void set_draffy(nlohmann::json const & value) { this->draffy = value; }
+
+        nlohmann::json const & get_foreigner() const { return foreigner; }
+        nlohmann::json & get_mutable_foreigner() { return foreigner; }
+        void set_foreigner(nlohmann::json const & value) { this->foreigner = value; }
+
+        nlohmann::json const & get_guyandot() const { return guyandot; }
+        nlohmann::json & get_mutable_guyandot() { return guyandot; }
+        void set_guyandot(nlohmann::json const & value) { this->guyandot = value; }
+
+        nlohmann::json const & get_neurogliosis() const { return neurogliosis; }
+        nlohmann::json & get_mutable_neurogliosis() { return neurogliosis; }
+        void set_neurogliosis(nlohmann::json const & value) { this->neurogliosis = value; }
+
+        nlohmann::json const & get_osmious() const { return osmious; }
+        nlohmann::json & get_mutable_osmious() { return osmious; }
+        void set_osmious(nlohmann::json const & value) { this->osmious = value; }
+
+        nlohmann::json const & get_palpitate() const { return palpitate; }
+        nlohmann::json & get_mutable_palpitate() { return palpitate; }
+        void set_palpitate(nlohmann::json const & value) { this->palpitate = value; }
+
+        nlohmann::json const & get_rebukeable() const { return rebukeable; }
+        nlohmann::json & get_mutable_rebukeable() { return rebukeable; }
+        void set_rebukeable(nlohmann::json const & value) { this->rebukeable = value; }
+
+        nlohmann::json const & get_reinwardtia() const { return reinwardtia; }
+        nlohmann::json & get_mutable_reinwardtia() { return reinwardtia; }
+        void set_reinwardtia(nlohmann::json const & value) { this->reinwardtia = value; }
+
+        nlohmann::json const & get_reservatory() const { return reservatory; }
+        nlohmann::json & get_mutable_reservatory() { return reservatory; }
+        void set_reservatory(nlohmann::json const & value) { this->reservatory = value; }
+
+        nlohmann::json const & get_scalt() const { return scalt; }
+        nlohmann::json & get_mutable_scalt() { return scalt; }
+        void set_scalt(nlohmann::json const & value) { this->scalt = value; }
+
+        nlohmann::json const & get_scripturalize() const { return scripturalize; }
+        nlohmann::json & get_mutable_scripturalize() { return scripturalize; }
+        void set_scripturalize(nlohmann::json const & value) { this->scripturalize = value; }
+
+        nlohmann::json const & get_tintometer() const { return tintometer; }
+        nlohmann::json & get_mutable_tintometer() { return tintometer; }
+        void set_tintometer(nlohmann::json const & value) { this->tintometer = value; }
+
+        nlohmann::json const & get_tritoness() const { return tritoness; }
+        nlohmann::json & get_mutable_tritoness() { return tritoness; }
+        void set_tritoness(nlohmann::json const & value) { this->tritoness = value; }
+
+        nlohmann::json const & get_undergrade() const { return undergrade; }
+        nlohmann::json & get_mutable_undergrade() { return undergrade; }
+        void set_undergrade(nlohmann::json const & value) { this->undergrade = value; }
+
+        nlohmann::json const & get_undermountain() const { return undermountain; }
+        nlohmann::json & get_mutable_undermountain() { return undermountain; }
+        void set_undermountain(nlohmann::json const & value) { this->undermountain = value; }
+    };
+
+    using FenkElement = std::variant<FenkClass, std::string>;
+
+    class FlagmakingClass {
+        public:
+        FlagmakingClass() = default;
+        virtual ~FlagmakingClass() = default;
+
+        private:
+        nlohmann::json albarco;
+        nlohmann::json bunodonta;
+        nlohmann::json hornify;
+        nlohmann::json hydrocorisae;
+        nlohmann::json hypoglossus;
+        nlohmann::json inexpiably;
+        nlohmann::json ingratitude;
+        nlohmann::json ladyfly;
+        nlohmann::json medicament;
+        nlohmann::json monogrammatic;
+        nlohmann::json nobbut;
+        nlohmann::json notacanthidae;
+        nlohmann::json polyplacophore;
+        nlohmann::json proexercise;
+        nlohmann::json protoplast;
+        nlohmann::json puzzling;
+        nlohmann::json splanchnoskeleton;
+        nlohmann::json unloveliness;
+        nlohmann::json unquarantined;
+        nlohmann::json unrenounceable;
+
+        public:
+        nlohmann::json const & get_albarco() const { return albarco; }
+        nlohmann::json & get_mutable_albarco() { return albarco; }
+        void set_albarco(nlohmann::json const & value) { this->albarco = value; }
+
+        nlohmann::json const & get_bunodonta() const { return bunodonta; }
+        nlohmann::json & get_mutable_bunodonta() { return bunodonta; }
+        void set_bunodonta(nlohmann::json const & value) { this->bunodonta = value; }
+
+        nlohmann::json const & get_hornify() const { return hornify; }
+        nlohmann::json & get_mutable_hornify() { return hornify; }
+        void set_hornify(nlohmann::json const & value) { this->hornify = value; }
+
+        nlohmann::json const & get_hydrocorisae() const { return hydrocorisae; }
+        nlohmann::json & get_mutable_hydrocorisae() { return hydrocorisae; }
+        void set_hydrocorisae(nlohmann::json const & value) { this->hydrocorisae = value; }
+
+        nlohmann::json const & get_hypoglossus() const { return hypoglossus; }
+        nlohmann::json & get_mutable_hypoglossus() { return hypoglossus; }
+        void set_hypoglossus(nlohmann::json const & value) { this->hypoglossus = value; }
+
+        nlohmann::json const & get_inexpiably() const { return inexpiably; }
+        nlohmann::json & get_mutable_inexpiably() { return inexpiably; }
+        void set_inexpiably(nlohmann::json const & value) { this->inexpiably = value; }
+
+        nlohmann::json const & get_ingratitude() const { return ingratitude; }
+        nlohmann::json & get_mutable_ingratitude() { return ingratitude; }
+        void set_ingratitude(nlohmann::json const & value) { this->ingratitude = value; }
+
+        nlohmann::json const & get_ladyfly() const { return ladyfly; }
+        nlohmann::json & get_mutable_ladyfly() { return ladyfly; }
+        void set_ladyfly(nlohmann::json const & value) { this->ladyfly = value; }
+
+        nlohmann::json const & get_medicament() const { return medicament; }
+        nlohmann::json & get_mutable_medicament() { return medicament; }
+        void set_medicament(nlohmann::json const & value) { this->medicament = value; }
+
+        nlohmann::json const & get_monogrammatic() const { return monogrammatic; }
+        nlohmann::json & get_mutable_monogrammatic() { return monogrammatic; }
+        void set_monogrammatic(nlohmann::json const & value) { this->monogrammatic = value; }
+
+        nlohmann::json const & get_nobbut() const { return nobbut; }
+        nlohmann::json & get_mutable_nobbut() { return nobbut; }
+        void set_nobbut(nlohmann::json const & value) { this->nobbut = value; }
+
+        nlohmann::json const & get_notacanthidae() const { return notacanthidae; }
+        nlohmann::json & get_mutable_notacanthidae() { return notacanthidae; }
+        void set_notacanthidae(nlohmann::json const & value) { this->notacanthidae = value; }
+
+        nlohmann::json const & get_polyplacophore() const { return polyplacophore; }
+        nlohmann::json & get_mutable_polyplacophore() { return polyplacophore; }
+        void set_polyplacophore(nlohmann::json const & value) { this->polyplacophore = value; }
+
+        nlohmann::json const & get_proexercise() const { return proexercise; }
+        nlohmann::json & get_mutable_proexercise() { return proexercise; }
+        void set_proexercise(nlohmann::json const & value) { this->proexercise = value; }
+
+        nlohmann::json const & get_protoplast() const { return protoplast; }
+        nlohmann::json & get_mutable_protoplast() { return protoplast; }
+        void set_protoplast(nlohmann::json const & value) { this->protoplast = value; }
+
+        nlohmann::json const & get_puzzling() const { return puzzling; }
+        nlohmann::json & get_mutable_puzzling() { return puzzling; }
+        void set_puzzling(nlohmann::json const & value) { this->puzzling = value; }
+
+        nlohmann::json const & get_splanchnoskeleton() const { return splanchnoskeleton; }
+        nlohmann::json & get_mutable_splanchnoskeleton() { return splanchnoskeleton; }
+        void set_splanchnoskeleton(nlohmann::json const & value) { this->splanchnoskeleton = value; }
+
+        nlohmann::json const & get_unloveliness() const { return unloveliness; }
+        nlohmann::json & get_mutable_unloveliness() { return unloveliness; }
+        void set_unloveliness(nlohmann::json const & value) { this->unloveliness = value; }
+
+        nlohmann::json const & get_unquarantined() const { return unquarantined; }
+        nlohmann::json & get_mutable_unquarantined() { return unquarantined; }
+        void set_unquarantined(nlohmann::json const & value) { this->unquarantined = value; }
+
+        nlohmann::json const & get_unrenounceable() const { return unrenounceable; }
+        nlohmann::json & get_mutable_unrenounceable() { return unrenounceable; }
+        void set_unrenounceable(nlohmann::json const & value) { this->unrenounceable = value; }
+    };
+
+    using FlagmakingElement = std::variant<bool, FlagmakingClass, double>;
+
+    using Fluorometer = std::optional<std::variant<int64_t, std::string>>;
+
+    using Fuzzy = std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>;
+
+    using Gardenward = std::variant<std::vector<int64_t>, bool, std::string>;
+
+    using Generalissimo = std::optional<std::variant<bool, std::map<std::string, int64_t>>>;
+
+    using Hemicrystalline = std::variant<CimeliaClass, std::string>;
+
+    class HemocoeleClass {
+        public:
+        HemocoeleClass() = default;
+        virtual ~HemocoeleClass() = default;
+
+        private:
+        nlohmann::json acrogamy;
+        nlohmann::json amelification;
+        nlohmann::json autobiographic;
+        nlohmann::json berat;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json disproportionably;
+        nlohmann::json erythrite;
+        nlohmann::json graphic;
+        nlohmann::json hepatological;
+        std::optional<bool> homocerc;
+        nlohmann::json incommensurably;
+        nlohmann::json misaffirm;
+        nlohmann::json nonbookish;
+        nlohmann::json pocketbook;
+        nlohmann::json sclerometric;
+        nlohmann::json stambouline;
+        nlohmann::json stickpin;
+        nlohmann::json tubulure;
+        nlohmann::json undelated;
+        nlohmann::json unsalt;
+        nlohmann::json untutelar;
+        nlohmann::json vagrant;
+        nlohmann::json walt;
+
+        public:
+        nlohmann::json const & get_acrogamy() const { return acrogamy; }
+        nlohmann::json & get_mutable_acrogamy() { return acrogamy; }
+        void set_acrogamy(nlohmann::json const & value) { this->acrogamy = value; }
+
+        nlohmann::json const & get_amelification() const { return amelification; }
+        nlohmann::json & get_mutable_amelification() { return amelification; }
+        void set_amelification(nlohmann::json const & value) { this->amelification = value; }
+
+        nlohmann::json const & get_autobiographic() const { return autobiographic; }
+        nlohmann::json & get_mutable_autobiographic() { return autobiographic; }
+        void set_autobiographic(nlohmann::json const & value) { this->autobiographic = value; }
+
+        nlohmann::json const & get_berat() const { return berat; }
+        nlohmann::json & get_mutable_berat() { return berat; }
+        void set_berat(nlohmann::json const & value) { this->berat = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_disproportionably() const { return disproportionably; }
+        nlohmann::json & get_mutable_disproportionably() { return disproportionably; }
+        void set_disproportionably(nlohmann::json const & value) { this->disproportionably = value; }
+
+        nlohmann::json const & get_erythrite() const { return erythrite; }
+        nlohmann::json & get_mutable_erythrite() { return erythrite; }
+        void set_erythrite(nlohmann::json const & value) { this->erythrite = value; }
+
+        nlohmann::json const & get_graphic() const { return graphic; }
+        nlohmann::json & get_mutable_graphic() { return graphic; }
+        void set_graphic(nlohmann::json const & value) { this->graphic = value; }
+
+        nlohmann::json const & get_hepatological() const { return hepatological; }
+        nlohmann::json & get_mutable_hepatological() { return hepatological; }
+        void set_hepatological(nlohmann::json const & value) { this->hepatological = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_incommensurably() const { return incommensurably; }
+        nlohmann::json & get_mutable_incommensurably() { return incommensurably; }
+        void set_incommensurably(nlohmann::json const & value) { this->incommensurably = value; }
+
+        nlohmann::json const & get_misaffirm() const { return misaffirm; }
+        nlohmann::json & get_mutable_misaffirm() { return misaffirm; }
+        void set_misaffirm(nlohmann::json const & value) { this->misaffirm = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_pocketbook() const { return pocketbook; }
+        nlohmann::json & get_mutable_pocketbook() { return pocketbook; }
+        void set_pocketbook(nlohmann::json const & value) { this->pocketbook = value; }
+
+        nlohmann::json const & get_sclerometric() const { return sclerometric; }
+        nlohmann::json & get_mutable_sclerometric() { return sclerometric; }
+        void set_sclerometric(nlohmann::json const & value) { this->sclerometric = value; }
+
+        nlohmann::json const & get_stambouline() const { return stambouline; }
+        nlohmann::json & get_mutable_stambouline() { return stambouline; }
+        void set_stambouline(nlohmann::json const & value) { this->stambouline = value; }
+
+        nlohmann::json const & get_stickpin() const { return stickpin; }
+        nlohmann::json & get_mutable_stickpin() { return stickpin; }
+        void set_stickpin(nlohmann::json const & value) { this->stickpin = value; }
+
+        nlohmann::json const & get_tubulure() const { return tubulure; }
+        nlohmann::json & get_mutable_tubulure() { return tubulure; }
+        void set_tubulure(nlohmann::json const & value) { this->tubulure = value; }
+
+        nlohmann::json const & get_undelated() const { return undelated; }
+        nlohmann::json & get_mutable_undelated() { return undelated; }
+        void set_undelated(nlohmann::json const & value) { this->undelated = value; }
+
+        nlohmann::json const & get_unsalt() const { return unsalt; }
+        nlohmann::json & get_mutable_unsalt() { return unsalt; }
+        void set_unsalt(nlohmann::json const & value) { this->unsalt = value; }
+
+        nlohmann::json const & get_untutelar() const { return untutelar; }
+        nlohmann::json & get_mutable_untutelar() { return untutelar; }
+        void set_untutelar(nlohmann::json const & value) { this->untutelar = value; }
+
+        nlohmann::json const & get_vagrant() const { return vagrant; }
+        nlohmann::json & get_mutable_vagrant() { return vagrant; }
+        void set_vagrant(nlohmann::json const & value) { this->vagrant = value; }
+
+        nlohmann::json const & get_walt() const { return walt; }
+        nlohmann::json & get_mutable_walt() { return walt; }
+        void set_walt(nlohmann::json const & value) { this->walt = value; }
+    };
+
+    using HemocoeleElement = std::variant<std::vector<int64_t>, HemocoeleClass>;
+
+    using Hoister = std::optional<std::variant<CimeliaClass, std::string>>;
+
+    using Hyperpiesi = std::optional<std::variant<std::vector<nlohmann::json>, CimeliaClass>>;
+
+    using Hyppish = std::optional<std::variant<bool, std::string>>;
+
+    using Idealizer = std::variant<std::vector<nlohmann::json>, CimeliaClass, int64_t>;
+
+    using Incrustator = std::variant<std::vector<int64_t>, int64_t, std::string>;
+
+    using Intentiveness = std::variant<CimeliaClass, double, std::string>;
+
+    class Interacinar {
+        public:
+        Interacinar() = default;
+        virtual ~Interacinar() = default;
+
+        private:
+        double assapan;
+        bool benefactorship;
+        std::string triseriatim;
+        int64_t tubbing;
+        nlohmann::json untrimmed;
+
+        public:
+        double const & get_assapan() const { return assapan; }
+        double & get_mutable_assapan() { return assapan; }
+        void set_assapan(double const & value) { this->assapan = value; }
+
+        bool const & get_benefactorship() const { return benefactorship; }
+        bool & get_mutable_benefactorship() { return benefactorship; }
+        void set_benefactorship(bool const & value) { this->benefactorship = value; }
+
+        std::string const & get_triseriatim() const { return triseriatim; }
+        std::string & get_mutable_triseriatim() { return triseriatim; }
+        void set_triseriatim(std::string const & value) { this->triseriatim = value; }
+
+        int64_t const & get_tubbing() const { return tubbing; }
+        int64_t & get_mutable_tubbing() { return tubbing; }
+        void set_tubbing(int64_t const & value) { this->tubbing = value; }
+
+        nlohmann::json const & get_untrimmed() const { return untrimmed; }
+        nlohmann::json & get_mutable_untrimmed() { return untrimmed; }
+        void set_untrimmed(nlohmann::json const & value) { this->untrimmed = value; }
+    };
+
+    using Jacutinga = std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::string centrodesmose;
+        std::vector<CerographElement> cerograph;
+        std::vector<ChemotherapeuticElement> chemotherapeutics;
+        std::vector<CimeliaElement> cimelia;
+        int64_t citrated;
+        std::vector<Clinodome> clinodome;
+        std::vector<CoadjustElement> coadjust;
+        std::vector<Consilience> consilience;
+        std::vector<Constructor> constructor;
+        std::vector<Continuative> continuative;
+        std::vector<CredulityElement> credulity;
+        std::vector<Creviced> creviced;
+        std::vector<std::vector<std::optional<int64_t>>> cubiculum;
+        std::vector<DeruralizeElement> deruralize;
+        std::vector<DiaereseElement> diaereses;
+        std::vector<std::optional<std::vector<nlohmann::json>>> dissolution;
+        std::vector<Downstroke> downstroke;
+        std::vector<std::optional<double>> electrotautomerism;
+        std::vector<Eleutheromania> eleutheromania;
+        Encrust encrust;
+        std::vector<Entomoid> entomoid;
+        std::vector<Epipaleolithic> epipaleolithic;
+        std::vector<Expropriable> expropriable;
+        std::vector<FagginglyElement> faggingly;
+        std::vector<FenkElement> fenks;
+        std::vector<FlagmakingElement> flagmaking;
+        std::vector<Fluorometer> fluorometer;
+        std::vector<std::optional<int64_t>> fulsome;
+        std::vector<Fuzzy> fuzzy;
+        std::vector<Gardenward> gardenwards;
+        std::vector<Generalissimo> generalissimo;
+        std::vector<std::optional<std::map<std::string, int64_t>>> habeas;
+        std::vector<Hemicrystalline> hemicrystalline;
+        std::vector<HemocoeleElement> hemocoele;
+        std::vector<Hoister> hoister;
+        std::vector<Hyperpiesi> hyperpiesis;
+        std::vector<Hyppish> hyppish;
+        std::vector<Idealizer> idealizer;
+        std::vector<Incrustator> incrustator;
+        std::vector<Intentiveness> intentiveness;
+        Interacinar interacinar;
+        std::vector<std::optional<std::vector<int64_t>>> intercorrelation;
+        std::vector<Jacutinga> jacutinga;
+
+        public:
+        std::string const & get_centrodesmose() const { return centrodesmose; }
+        std::string & get_mutable_centrodesmose() { return centrodesmose; }
+        void set_centrodesmose(std::string const & value) { this->centrodesmose = value; }
+
+        std::vector<CerographElement> const & get_cerograph() const { return cerograph; }
+        std::vector<CerographElement> & get_mutable_cerograph() { return cerograph; }
+        void set_cerograph(std::vector<CerographElement> const & value) { this->cerograph = value; }
+
+        std::vector<ChemotherapeuticElement> const & get_chemotherapeutics() const { return chemotherapeutics; }
+        std::vector<ChemotherapeuticElement> & get_mutable_chemotherapeutics() { return chemotherapeutics; }
+        void set_chemotherapeutics(std::vector<ChemotherapeuticElement> const & value) { this->chemotherapeutics = value; }
+
+        std::vector<CimeliaElement> const & get_cimelia() const { return cimelia; }
+        std::vector<CimeliaElement> & get_mutable_cimelia() { return cimelia; }
+        void set_cimelia(std::vector<CimeliaElement> const & value) { this->cimelia = value; }
+
+        int64_t const & get_citrated() const { return citrated; }
+        int64_t & get_mutable_citrated() { return citrated; }
+        void set_citrated(int64_t const & value) { this->citrated = value; }
+
+        std::vector<Clinodome> const & get_clinodome() const { return clinodome; }
+        std::vector<Clinodome> & get_mutable_clinodome() { return clinodome; }
+        void set_clinodome(std::vector<Clinodome> const & value) { this->clinodome = value; }
+
+        std::vector<CoadjustElement> const & get_coadjust() const { return coadjust; }
+        std::vector<CoadjustElement> & get_mutable_coadjust() { return coadjust; }
+        void set_coadjust(std::vector<CoadjustElement> const & value) { this->coadjust = value; }
+
+        std::vector<Consilience> const & get_consilience() const { return consilience; }
+        std::vector<Consilience> & get_mutable_consilience() { return consilience; }
+        void set_consilience(std::vector<Consilience> const & value) { this->consilience = value; }
+
+        std::vector<Constructor> const & get_constructor() const { return constructor; }
+        std::vector<Constructor> & get_mutable_constructor() { return constructor; }
+        void set_constructor(std::vector<Constructor> const & value) { this->constructor = value; }
+
+        std::vector<Continuative> const & get_continuative() const { return continuative; }
+        std::vector<Continuative> & get_mutable_continuative() { return continuative; }
+        void set_continuative(std::vector<Continuative> const & value) { this->continuative = value; }
+
+        std::vector<CredulityElement> const & get_credulity() const { return credulity; }
+        std::vector<CredulityElement> & get_mutable_credulity() { return credulity; }
+        void set_credulity(std::vector<CredulityElement> const & value) { this->credulity = value; }
+
+        std::vector<Creviced> const & get_creviced() const { return creviced; }
+        std::vector<Creviced> & get_mutable_creviced() { return creviced; }
+        void set_creviced(std::vector<Creviced> const & value) { this->creviced = value; }
+
+        std::vector<std::vector<std::optional<int64_t>>> const & get_cubiculum() const { return cubiculum; }
+        std::vector<std::vector<std::optional<int64_t>>> & get_mutable_cubiculum() { return cubiculum; }
+        void set_cubiculum(std::vector<std::vector<std::optional<int64_t>>> const & value) { this->cubiculum = value; }
+
+        std::vector<DeruralizeElement> const & get_deruralize() const { return deruralize; }
+        std::vector<DeruralizeElement> & get_mutable_deruralize() { return deruralize; }
+        void set_deruralize(std::vector<DeruralizeElement> const & value) { this->deruralize = value; }
+
+        std::vector<DiaereseElement> const & get_diaereses() const { return diaereses; }
+        std::vector<DiaereseElement> & get_mutable_diaereses() { return diaereses; }
+        void set_diaereses(std::vector<DiaereseElement> const & value) { this->diaereses = value; }
+
+        std::vector<std::optional<std::vector<nlohmann::json>>> const & get_dissolution() const { return dissolution; }
+        std::vector<std::optional<std::vector<nlohmann::json>>> & get_mutable_dissolution() { return dissolution; }
+        void set_dissolution(std::vector<std::optional<std::vector<nlohmann::json>>> const & value) { this->dissolution = value; }
+
+        std::vector<Downstroke> const & get_downstroke() const { return downstroke; }
+        std::vector<Downstroke> & get_mutable_downstroke() { return downstroke; }
+        void set_downstroke(std::vector<Downstroke> const & value) { this->downstroke = value; }
+
+        std::vector<std::optional<double>> const & get_electrotautomerism() const { return electrotautomerism; }
+        std::vector<std::optional<double>> & get_mutable_electrotautomerism() { return electrotautomerism; }
+        void set_electrotautomerism(std::vector<std::optional<double>> const & value) { this->electrotautomerism = value; }
+
+        std::vector<Eleutheromania> const & get_eleutheromania() const { return eleutheromania; }
+        std::vector<Eleutheromania> & get_mutable_eleutheromania() { return eleutheromania; }
+        void set_eleutheromania(std::vector<Eleutheromania> const & value) { this->eleutheromania = value; }
+
+        Encrust const & get_encrust() const { return encrust; }
+        Encrust & get_mutable_encrust() { return encrust; }
+        void set_encrust(Encrust const & value) { this->encrust = value; }
+
+        std::vector<Entomoid> const & get_entomoid() const { return entomoid; }
+        std::vector<Entomoid> & get_mutable_entomoid() { return entomoid; }
+        void set_entomoid(std::vector<Entomoid> const & value) { this->entomoid = value; }
+
+        std::vector<Epipaleolithic> const & get_epipaleolithic() const { return epipaleolithic; }
+        std::vector<Epipaleolithic> & get_mutable_epipaleolithic() { return epipaleolithic; }
+        void set_epipaleolithic(std::vector<Epipaleolithic> const & value) { this->epipaleolithic = value; }
+
+        std::vector<Expropriable> const & get_expropriable() const { return expropriable; }
+        std::vector<Expropriable> & get_mutable_expropriable() { return expropriable; }
+        void set_expropriable(std::vector<Expropriable> const & value) { this->expropriable = value; }
+
+        std::vector<FagginglyElement> const & get_faggingly() const { return faggingly; }
+        std::vector<FagginglyElement> & get_mutable_faggingly() { return faggingly; }
+        void set_faggingly(std::vector<FagginglyElement> const & value) { this->faggingly = value; }
+
+        std::vector<FenkElement> const & get_fenks() const { return fenks; }
+        std::vector<FenkElement> & get_mutable_fenks() { return fenks; }
+        void set_fenks(std::vector<FenkElement> const & value) { this->fenks = value; }
+
+        std::vector<FlagmakingElement> const & get_flagmaking() const { return flagmaking; }
+        std::vector<FlagmakingElement> & get_mutable_flagmaking() { return flagmaking; }
+        void set_flagmaking(std::vector<FlagmakingElement> const & value) { this->flagmaking = value; }
+
+        std::vector<Fluorometer> const & get_fluorometer() const { return fluorometer; }
+        std::vector<Fluorometer> & get_mutable_fluorometer() { return fluorometer; }
+        void set_fluorometer(std::vector<Fluorometer> const & value) { this->fluorometer = value; }
+
+        std::vector<std::optional<int64_t>> const & get_fulsome() const { return fulsome; }
+        std::vector<std::optional<int64_t>> & get_mutable_fulsome() { return fulsome; }
+        void set_fulsome(std::vector<std::optional<int64_t>> const & value) { this->fulsome = value; }
+
+        std::vector<Fuzzy> const & get_fuzzy() const { return fuzzy; }
+        std::vector<Fuzzy> & get_mutable_fuzzy() { return fuzzy; }
+        void set_fuzzy(std::vector<Fuzzy> const & value) { this->fuzzy = value; }
+
+        std::vector<Gardenward> const & get_gardenwards() const { return gardenwards; }
+        std::vector<Gardenward> & get_mutable_gardenwards() { return gardenwards; }
+        void set_gardenwards(std::vector<Gardenward> const & value) { this->gardenwards = value; }
+
+        std::vector<Generalissimo> const & get_generalissimo() const { return generalissimo; }
+        std::vector<Generalissimo> & get_mutable_generalissimo() { return generalissimo; }
+        void set_generalissimo(std::vector<Generalissimo> const & value) { this->generalissimo = value; }
+
+        std::vector<std::optional<std::map<std::string, int64_t>>> const & get_habeas() const { return habeas; }
+        std::vector<std::optional<std::map<std::string, int64_t>>> & get_mutable_habeas() { return habeas; }
+        void set_habeas(std::vector<std::optional<std::map<std::string, int64_t>>> const & value) { this->habeas = value; }
+
+        std::vector<Hemicrystalline> const & get_hemicrystalline() const { return hemicrystalline; }
+        std::vector<Hemicrystalline> & get_mutable_hemicrystalline() { return hemicrystalline; }
+        void set_hemicrystalline(std::vector<Hemicrystalline> const & value) { this->hemicrystalline = value; }
+
+        std::vector<HemocoeleElement> const & get_hemocoele() const { return hemocoele; }
+        std::vector<HemocoeleElement> & get_mutable_hemocoele() { return hemocoele; }
+        void set_hemocoele(std::vector<HemocoeleElement> const & value) { this->hemocoele = value; }
+
+        std::vector<Hoister> const & get_hoister() const { return hoister; }
+        std::vector<Hoister> & get_mutable_hoister() { return hoister; }
+        void set_hoister(std::vector<Hoister> const & value) { this->hoister = value; }
+
+        std::vector<Hyperpiesi> const & get_hyperpiesis() const { return hyperpiesis; }
+        std::vector<Hyperpiesi> & get_mutable_hyperpiesis() { return hyperpiesis; }
+        void set_hyperpiesis(std::vector<Hyperpiesi> const & value) { this->hyperpiesis = value; }
+
+        std::vector<Hyppish> const & get_hyppish() const { return hyppish; }
+        std::vector<Hyppish> & get_mutable_hyppish() { return hyppish; }
+        void set_hyppish(std::vector<Hyppish> const & value) { this->hyppish = value; }
+
+        std::vector<Idealizer> const & get_idealizer() const { return idealizer; }
+        std::vector<Idealizer> & get_mutable_idealizer() { return idealizer; }
+        void set_idealizer(std::vector<Idealizer> const & value) { this->idealizer = value; }
+
+        std::vector<Incrustator> const & get_incrustator() const { return incrustator; }
+        std::vector<Incrustator> & get_mutable_incrustator() { return incrustator; }
+        void set_incrustator(std::vector<Incrustator> const & value) { this->incrustator = value; }
+
+        std::vector<Intentiveness> const & get_intentiveness() const { return intentiveness; }
+        std::vector<Intentiveness> & get_mutable_intentiveness() { return intentiveness; }
+        void set_intentiveness(std::vector<Intentiveness> const & value) { this->intentiveness = value; }
+
+        Interacinar const & get_interacinar() const { return interacinar; }
+        Interacinar & get_mutable_interacinar() { return interacinar; }
+        void set_interacinar(Interacinar const & value) { this->interacinar = value; }
+
+        std::vector<std::optional<std::vector<int64_t>>> const & get_intercorrelation() const { return intercorrelation; }
+        std::vector<std::optional<std::vector<int64_t>>> & get_mutable_intercorrelation() { return intercorrelation; }
+        void set_intercorrelation(std::vector<std::optional<std::vector<int64_t>>> const & value) { this->intercorrelation = value; }
+
+        std::vector<Jacutinga> const & get_jacutinga() const { return jacutinga; }
+        std::vector<Jacutinga> & get_mutable_jacutinga() { return jacutinga; }
+        void set_jacutinga(std::vector<Jacutinga> const & value) { this->jacutinga = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(json const & j, CerographClass & x);
+void to_json(json & j, CerographClass const & x);
+
+void from_json(json const & j, ChemotherapeuticClass & x);
+void to_json(json & j, ChemotherapeuticClass const & x);
+
+void from_json(json const & j, CimeliaClass & x);
+void to_json(json & j, CimeliaClass const & x);
+
+void from_json(json const & j, CoadjustClass & x);
+void to_json(json & j, CoadjustClass const & x);
+
+void from_json(json const & j, CredulityClass & x);
+void to_json(json & j, CredulityClass const & x);
+
+void from_json(json const & j, DeruralizeClass & x);
+void to_json(json & j, DeruralizeClass const & x);
+
+void from_json(json const & j, DiaereseClass & x);
+void to_json(json & j, DiaereseClass const & x);
+
+void from_json(json const & j, Encrust & x);
+void to_json(json & j, Encrust const & x);
+
+void from_json(json const & j, FagginglyClass & x);
+void to_json(json & j, FagginglyClass const & x);
+
+void from_json(json const & j, FenkClass & x);
+void to_json(json & j, FenkClass const & x);
+
+void from_json(json const & j, FlagmakingClass & x);
+void to_json(json & j, FlagmakingClass const & x);
+
+void from_json(json const & j, HemocoeleClass & x);
+void to_json(json & j, HemocoeleClass const & x);
+
+void from_json(json const & j, Interacinar & x);
+void to_json(json & j, Interacinar const & x);
+
+void from_json(json const & j, TopLevel & x);
+void to_json(json & j, TopLevel const & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<quicktype::CerographClass, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::CerographClass, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::CerographClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>> {
+    static void from_json(json const & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> & x);
+    static void to_json(json & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(json const & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, std::variant<double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CoadjustClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::CoadjustClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::CoadjustClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<double, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(json const & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::CredulityClass, int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::CredulityClass, int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<bool, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<bool, std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<double, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<double, std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>> {
+    static void from_json(json const & j, std::variant<quicktype::CimeliaClass, int64_t> & x);
+    static void to_json(json & j, std::variant<quicktype::CimeliaClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FagginglyClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::FagginglyClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::FagginglyClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FenkClass, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::FenkClass, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::FenkClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::FlagmakingClass, double> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::FlagmakingClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(json const & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<bool, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::CimeliaClass, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::CimeliaClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::CimeliaClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::CimeliaClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::string>> {
+    static void from_json(json const & j, std::variant<bool, std::string> & x);
+    static void to_json(json & j, std::variant<bool, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::CimeliaClass, double, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::CimeliaClass, double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> const & x);
+};
+}
+namespace quicktype {
+    inline void from_json(json const & j, CerographClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apotropaion(get_untyped(j, "apotropaion"));
+        x.set_casuary(get_untyped(j, "casuary"));
+        x.set_creaker(get_untyped(j, "creaker"));
+        x.set_disqualification(get_untyped(j, "disqualification"));
+        x.set_imperatorious(get_untyped(j, "imperatorious"));
+        x.set_impermeabilize(get_untyped(j, "impermeabilize"));
+        x.set_metastoma(get_untyped(j, "metastoma"));
+        x.set_noctidiurnal(get_untyped(j, "noctidiurnal"));
+        x.set_nonreserve(get_untyped(j, "nonreserve"));
+        x.set_ophthalmotonometry(get_untyped(j, "ophthalmotonometry"));
+        x.set_pailful(get_untyped(j, "pailful"));
+        x.set_pigfish(get_untyped(j, "pigfish"));
+        x.set_pongee(get_untyped(j, "pongee"));
+        x.set_prosodical(get_untyped(j, "prosodical"));
+        x.set_scrofuloderm(get_untyped(j, "scrofuloderm"));
+        x.set_storekeeping(get_untyped(j, "storekeeping"));
+        x.set_therologist(get_untyped(j, "therologist"));
+        x.set_tolowa(get_untyped(j, "Tolowa"));
+        x.set_tradeful(get_untyped(j, "tradeful"));
+        x.set_unriveting(get_untyped(j, "unriveting"));
+    }
+
+    inline void to_json(json & j, CerographClass const & x) {
+        j = json::object();
+        j["apotropaion"] = x.get_apotropaion();
+        j["casuary"] = x.get_casuary();
+        j["creaker"] = x.get_creaker();
+        j["disqualification"] = x.get_disqualification();
+        j["imperatorious"] = x.get_imperatorious();
+        j["impermeabilize"] = x.get_impermeabilize();
+        j["metastoma"] = x.get_metastoma();
+        j["noctidiurnal"] = x.get_noctidiurnal();
+        j["nonreserve"] = x.get_nonreserve();
+        j["ophthalmotonometry"] = x.get_ophthalmotonometry();
+        j["pailful"] = x.get_pailful();
+        j["pigfish"] = x.get_pigfish();
+        j["pongee"] = x.get_pongee();
+        j["prosodical"] = x.get_prosodical();
+        j["scrofuloderm"] = x.get_scrofuloderm();
+        j["storekeeping"] = x.get_storekeeping();
+        j["therologist"] = x.get_therologist();
+        j["Tolowa"] = x.get_tolowa();
+        j["tradeful"] = x.get_tradeful();
+        j["unriveting"] = x.get_unriveting();
+    }
+
+    inline void from_json(json const & j, ChemotherapeuticClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_angioneurotic(get_untyped(j, "angioneurotic"));
+        x.set_availment(get_untyped(j, "availment"));
+        x.set_bladelet(get_untyped(j, "bladelet"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_caulis(get_untyped(j, "caulis"));
+        x.set_chalcus(get_untyped(j, "chalcus"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_enteradenological(get_untyped(j, "enteradenological"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_imporosity(get_untyped(j, "imporosity"));
+        x.set_insistently(get_untyped(j, "insistently"));
+        x.set_intraparietal(get_untyped(j, "intraparietal"));
+        x.set_ivied(get_untyped(j, "ivied"));
+        x.set_maureen(get_untyped(j, "Maureen"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_nostochine(get_untyped(j, "nostochine"));
+        x.set_nutcracker(get_untyped(j, "nutcracker"));
+        x.set_ofttimes(get_untyped(j, "ofttimes"));
+        x.set_phenocryst(get_untyped(j, "phenocryst"));
+        x.set_precoincident(get_untyped(j, "precoincident"));
+        x.set_ramiferous(get_untyped(j, "ramiferous"));
+        x.set_stagmometer(get_untyped(j, "stagmometer"));
+        x.set_tetherball(get_untyped(j, "tetherball"));
+        x.set_unshy(get_untyped(j, "unshy"));
+    }
+
+    inline void to_json(json & j, ChemotherapeuticClass const & x) {
+        j = json::object();
+        j["angioneurotic"] = x.get_angioneurotic();
+        j["availment"] = x.get_availment();
+        j["bladelet"] = x.get_bladelet();
+        j["catharticalness"] = x.get_catharticalness();
+        j["caulis"] = x.get_caulis();
+        j["chalcus"] = x.get_chalcus();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["enteradenological"] = x.get_enteradenological();
+        j["homocerc"] = x.get_homocerc();
+        j["imporosity"] = x.get_imporosity();
+        j["insistently"] = x.get_insistently();
+        j["intraparietal"] = x.get_intraparietal();
+        j["ivied"] = x.get_ivied();
+        j["Maureen"] = x.get_maureen();
+        j["nonbookish"] = x.get_nonbookish();
+        j["nostochine"] = x.get_nostochine();
+        j["nutcracker"] = x.get_nutcracker();
+        j["ofttimes"] = x.get_ofttimes();
+        j["phenocryst"] = x.get_phenocryst();
+        j["precoincident"] = x.get_precoincident();
+        j["ramiferous"] = x.get_ramiferous();
+        j["stagmometer"] = x.get_stagmometer();
+        j["tetherball"] = x.get_tetherball();
+        j["unshy"] = x.get_unshy();
+    }
+
+    inline void from_json(json const & j, CimeliaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, CimeliaClass const & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(json const & j, CoadjustClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amidosulphonal(get_untyped(j, "amidosulphonal"));
+        x.set_benny(get_untyped(j, "Benny"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ensnare(get_untyped(j, "ensnare"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_hybridizer(get_untyped(j, "hybridizer"));
+        x.set_leastwise(get_untyped(j, "leastwise"));
+        x.set_lof(get_untyped(j, "lof"));
+        x.set_monkhood(get_untyped(j, "monkhood"));
+        x.set_netherlandish(get_untyped(j, "Netherlandish"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_peonism(get_untyped(j, "peonism"));
+        x.set_phonelescope(get_untyped(j, "Phonelescope"));
+        x.set_porphyrogeniture(get_untyped(j, "porphyrogeniture"));
+        x.set_preindemnify(get_untyped(j, "preindemnify"));
+        x.set_rosal(get_untyped(j, "rosal"));
+        x.set_scalenous(get_untyped(j, "scalenous"));
+        x.set_scopine(get_untyped(j, "scopine"));
+        x.set_sedaceae(get_untyped(j, "Sedaceae"));
+        x.set_suberinize(get_untyped(j, "suberinize"));
+        x.set_symbiot(get_untyped(j, "symbiot"));
+        x.set_tablefellow(get_untyped(j, "tablefellow"));
+        x.set_unchargeable(get_untyped(j, "unchargeable"));
+    }
+
+    inline void to_json(json & j, CoadjustClass const & x) {
+        j = json::object();
+        j["amidosulphonal"] = x.get_amidosulphonal();
+        j["Benny"] = x.get_benny();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ensnare"] = x.get_ensnare();
+        j["homocerc"] = x.get_homocerc();
+        j["hybridizer"] = x.get_hybridizer();
+        j["leastwise"] = x.get_leastwise();
+        j["lof"] = x.get_lof();
+        j["monkhood"] = x.get_monkhood();
+        j["Netherlandish"] = x.get_netherlandish();
+        j["nonbookish"] = x.get_nonbookish();
+        j["peonism"] = x.get_peonism();
+        j["Phonelescope"] = x.get_phonelescope();
+        j["porphyrogeniture"] = x.get_porphyrogeniture();
+        j["preindemnify"] = x.get_preindemnify();
+        j["rosal"] = x.get_rosal();
+        j["scalenous"] = x.get_scalenous();
+        j["scopine"] = x.get_scopine();
+        j["Sedaceae"] = x.get_sedaceae();
+        j["suberinize"] = x.get_suberinize();
+        j["symbiot"] = x.get_symbiot();
+        j["tablefellow"] = x.get_tablefellow();
+        j["unchargeable"] = x.get_unchargeable();
+    }
+
+    inline void from_json(json const & j, CredulityClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_ammonolytic(get_untyped(j, "ammonolytic"));
+        x.set_bushmaster(get_untyped(j, "bushmaster"));
+        x.set_considering(get_untyped(j, "considering"));
+        x.set_consuetudinary(get_untyped(j, "consuetudinary"));
+        x.set_embarras(get_untyped(j, "embarras"));
+        x.set_fineness(get_untyped(j, "fineness"));
+        x.set_flaithship(get_untyped(j, "flaithship"));
+        x.set_flavia(get_untyped(j, "Flavia"));
+        x.set_gruffly(get_untyped(j, "gruffly"));
+        x.set_hedychium(get_untyped(j, "Hedychium"));
+        x.set_leadwort(get_untyped(j, "leadwort"));
+        x.set_overseriously(get_untyped(j, "overseriously"));
+        x.set_parabola(get_untyped(j, "parabola"));
+        x.set_pectinatodenticulate(get_untyped(j, "pectinatodenticulate"));
+        x.set_popean(get_untyped(j, "Popean"));
+        x.set_pornocrat(get_untyped(j, "pornocrat"));
+        x.set_quadrisect(get_untyped(j, "quadrisect"));
+        x.set_seriality(get_untyped(j, "seriality"));
+        x.set_vamphorn(get_untyped(j, "vamphorn"));
+        x.set_wharp(get_untyped(j, "wharp"));
+    }
+
+    inline void to_json(json & j, CredulityClass const & x) {
+        j = json::object();
+        j["ammonolytic"] = x.get_ammonolytic();
+        j["bushmaster"] = x.get_bushmaster();
+        j["considering"] = x.get_considering();
+        j["consuetudinary"] = x.get_consuetudinary();
+        j["embarras"] = x.get_embarras();
+        j["fineness"] = x.get_fineness();
+        j["flaithship"] = x.get_flaithship();
+        j["Flavia"] = x.get_flavia();
+        j["gruffly"] = x.get_gruffly();
+        j["Hedychium"] = x.get_hedychium();
+        j["leadwort"] = x.get_leadwort();
+        j["overseriously"] = x.get_overseriously();
+        j["parabola"] = x.get_parabola();
+        j["pectinatodenticulate"] = x.get_pectinatodenticulate();
+        j["Popean"] = x.get_popean();
+        j["pornocrat"] = x.get_pornocrat();
+        j["quadrisect"] = x.get_quadrisect();
+        j["seriality"] = x.get_seriality();
+        j["vamphorn"] = x.get_vamphorn();
+        j["wharp"] = x.get_wharp();
+    }
+
+    inline void from_json(json const & j, DeruralizeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_bockerel(get_untyped(j, "bockerel"));
+        x.set_boulder(get_untyped(j, "boulder"));
+        x.set_churrus(get_untyped(j, "churrus"));
+        x.set_counterdigged(get_untyped(j, "counterdigged"));
+        x.set_dialogite(get_untyped(j, "dialogite"));
+        x.set_digenic(get_untyped(j, "digenic"));
+        x.set_dunbird(get_untyped(j, "dunbird"));
+        x.set_ergatogyne(get_untyped(j, "ergatogyne"));
+        x.set_fiendful(get_untyped(j, "fiendful"));
+        x.set_jackrod(get_untyped(j, "jackrod"));
+        x.set_jehovistic(get_untyped(j, "Jehovistic"));
+        x.set_paninean(get_untyped(j, "Paninean"));
+        x.set_panther(get_untyped(j, "panther"));
+        x.set_placentigerous(get_untyped(j, "placentigerous"));
+        x.set_romney(get_untyped(j, "Romney"));
+        x.set_sparm(get_untyped(j, "sparm"));
+        x.set_tocsin(get_untyped(j, "tocsin"));
+        x.set_unnicked(get_untyped(j, "unnicked"));
+        x.set_unstavable(get_untyped(j, "unstavable"));
+        x.set_windfirm(get_untyped(j, "windfirm"));
+    }
+
+    inline void to_json(json & j, DeruralizeClass const & x) {
+        j = json::object();
+        j["bockerel"] = x.get_bockerel();
+        j["boulder"] = x.get_boulder();
+        j["churrus"] = x.get_churrus();
+        j["counterdigged"] = x.get_counterdigged();
+        j["dialogite"] = x.get_dialogite();
+        j["digenic"] = x.get_digenic();
+        j["dunbird"] = x.get_dunbird();
+        j["ergatogyne"] = x.get_ergatogyne();
+        j["fiendful"] = x.get_fiendful();
+        j["jackrod"] = x.get_jackrod();
+        j["Jehovistic"] = x.get_jehovistic();
+        j["Paninean"] = x.get_paninean();
+        j["panther"] = x.get_panther();
+        j["placentigerous"] = x.get_placentigerous();
+        j["Romney"] = x.get_romney();
+        j["sparm"] = x.get_sparm();
+        j["tocsin"] = x.get_tocsin();
+        j["unnicked"] = x.get_unnicked();
+        j["unstavable"] = x.get_unstavable();
+        j["windfirm"] = x.get_windfirm();
+    }
+
+    inline void from_json(json const & j, DiaereseClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amoreuxia(get_untyped(j, "Amoreuxia"));
+        x.set_ani(get_untyped(j, "ani"));
+        x.set_bernicle(get_untyped(j, "bernicle"));
+        x.set_blackwasher(get_untyped(j, "blackwasher"));
+        x.set_blowhard(get_untyped(j, "blowhard"));
+        x.set_broma(get_untyped(j, "broma"));
+        x.set_closecross(get_untyped(j, "closecross"));
+        x.set_congregationalism(get_untyped(j, "congregationalism"));
+        x.set_grayly(get_untyped(j, "grayly"));
+        x.set_historically(get_untyped(j, "historically"));
+        x.set_hoast(get_untyped(j, "hoast"));
+        x.set_irretentive(get_untyped(j, "irretentive"));
+        x.set_parcener(get_untyped(j, "parcener"));
+        x.set_pedder(get_untyped(j, "pedder"));
+        x.set_pseudoanatomic(get_untyped(j, "pseudoanatomic"));
+        x.set_rhizocarpian(get_untyped(j, "rhizocarpian"));
+        x.set_samel(get_untyped(j, "samel"));
+        x.set_silker(get_untyped(j, "silker"));
+        x.set_subdentated(get_untyped(j, "subdentated"));
+        x.set_subobscure(get_untyped(j, "subobscure"));
+    }
+
+    inline void to_json(json & j, DiaereseClass const & x) {
+        j = json::object();
+        j["Amoreuxia"] = x.get_amoreuxia();
+        j["ani"] = x.get_ani();
+        j["bernicle"] = x.get_bernicle();
+        j["blackwasher"] = x.get_blackwasher();
+        j["blowhard"] = x.get_blowhard();
+        j["broma"] = x.get_broma();
+        j["closecross"] = x.get_closecross();
+        j["congregationalism"] = x.get_congregationalism();
+        j["grayly"] = x.get_grayly();
+        j["historically"] = x.get_historically();
+        j["hoast"] = x.get_hoast();
+        j["irretentive"] = x.get_irretentive();
+        j["parcener"] = x.get_parcener();
+        j["pedder"] = x.get_pedder();
+        j["pseudoanatomic"] = x.get_pseudoanatomic();
+        j["rhizocarpian"] = x.get_rhizocarpian();
+        j["samel"] = x.get_samel();
+        j["silker"] = x.get_silker();
+        j["subdentated"] = x.get_subdentated();
+        j["subobscure"] = x.get_subobscure();
+    }
+
+    inline void from_json(json const & j, Encrust& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_comradely(get_untyped(j, "comradely"));
+        x.set_diacanthous(get_untyped(j, "diacanthous"));
+        x.set_feminineness(get_untyped(j, "feminineness"));
+        x.set_gossamered(get_untyped(j, "gossamered"));
+        x.set_hibernia(get_untyped(j, "Hibernia"));
+        x.set_hibiscus(get_untyped(j, "Hibiscus"));
+        x.set_lepidosauria(get_untyped(j, "Lepidosauria"));
+        x.set_lollingly(get_untyped(j, "lollingly"));
+        x.set_manager(get_untyped(j, "manager"));
+        x.set_mechanic(get_untyped(j, "mechanic"));
+        x.set_overminuteness(get_untyped(j, "overminuteness"));
+        x.set_papelonne(get_untyped(j, "papelonne"));
+        x.set_plebification(get_untyped(j, "plebification"));
+        x.set_pugmiller(get_untyped(j, "pugmiller"));
+        x.set_recoveror(get_untyped(j, "recoveror"));
+        x.set_spermatoblastic(get_untyped(j, "spermatoblastic"));
+        x.set_syllidae(get_untyped(j, "Syllidae"));
+        x.set_ungyved(get_untyped(j, "ungyved"));
+        x.set_whirlabout(get_untyped(j, "whirlabout"));
+        x.set_woodenware(get_untyped(j, "woodenware"));
+    }
+
+    inline void to_json(json & j, Encrust const & x) {
+        j = json::object();
+        j["comradely"] = x.get_comradely();
+        j["diacanthous"] = x.get_diacanthous();
+        j["feminineness"] = x.get_feminineness();
+        j["gossamered"] = x.get_gossamered();
+        j["Hibernia"] = x.get_hibernia();
+        j["Hibiscus"] = x.get_hibiscus();
+        j["Lepidosauria"] = x.get_lepidosauria();
+        j["lollingly"] = x.get_lollingly();
+        j["manager"] = x.get_manager();
+        j["mechanic"] = x.get_mechanic();
+        j["overminuteness"] = x.get_overminuteness();
+        j["papelonne"] = x.get_papelonne();
+        j["plebification"] = x.get_plebification();
+        j["pugmiller"] = x.get_pugmiller();
+        j["recoveror"] = x.get_recoveror();
+        j["spermatoblastic"] = x.get_spermatoblastic();
+        j["Syllidae"] = x.get_syllidae();
+        j["ungyved"] = x.get_ungyved();
+        j["whirlabout"] = x.get_whirlabout();
+        j["woodenware"] = x.get_woodenware();
+    }
+
+    inline void from_json(json const & j, FagginglyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_abranchian(get_untyped(j, "abranchian"));
+        x.set_aculeiform(get_untyped(j, "aculeiform"));
+        x.set_adiaphoristic(get_untyped(j, "adiaphoristic"));
+        x.set_adoptionism(get_untyped(j, "adoptionism"));
+        x.set_anglic(get_untyped(j, "Anglic"));
+        x.set_antrotomy(get_untyped(j, "antrotomy"));
+        x.set_coerciveness(get_untyped(j, "coerciveness"));
+        x.set_decorist(get_untyped(j, "decorist"));
+        x.set_duckhood(get_untyped(j, "duckhood"));
+        x.set_heteromeri(get_untyped(j, "Heteromeri"));
+        x.set_hypochnose(get_untyped(j, "hypochnose"));
+        x.set_lochage(get_untyped(j, "lochage"));
+        x.set_melee(get_untyped(j, "melee"));
+        x.set_nonconformitant(get_untyped(j, "nonconformitant"));
+        x.set_poinsettia(get_untyped(j, "Poinsettia"));
+        x.set_putatively(get_untyped(j, "putatively"));
+        x.set_semivolatile(get_untyped(j, "semivolatile"));
+        x.set_soleas(get_untyped(j, "soleas"));
+        x.set_unfastenable(get_untyped(j, "unfastenable"));
+        x.set_unmillinered(get_untyped(j, "unmillinered"));
+    }
+
+    inline void to_json(json & j, FagginglyClass const & x) {
+        j = json::object();
+        j["abranchian"] = x.get_abranchian();
+        j["aculeiform"] = x.get_aculeiform();
+        j["adiaphoristic"] = x.get_adiaphoristic();
+        j["adoptionism"] = x.get_adoptionism();
+        j["Anglic"] = x.get_anglic();
+        j["antrotomy"] = x.get_antrotomy();
+        j["coerciveness"] = x.get_coerciveness();
+        j["decorist"] = x.get_decorist();
+        j["duckhood"] = x.get_duckhood();
+        j["Heteromeri"] = x.get_heteromeri();
+        j["hypochnose"] = x.get_hypochnose();
+        j["lochage"] = x.get_lochage();
+        j["melee"] = x.get_melee();
+        j["nonconformitant"] = x.get_nonconformitant();
+        j["Poinsettia"] = x.get_poinsettia();
+        j["putatively"] = x.get_putatively();
+        j["semivolatile"] = x.get_semivolatile();
+        j["soleas"] = x.get_soleas();
+        j["unfastenable"] = x.get_unfastenable();
+        j["unmillinered"] = x.get_unmillinered();
+    }
+
+    inline void from_json(json const & j, FenkClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apoise(get_untyped(j, "apoise"));
+        x.set_astronomize(get_untyped(j, "astronomize"));
+        x.set_cockhorse(get_untyped(j, "cockhorse"));
+        x.set_copular(get_untyped(j, "copular"));
+        x.set_dagomba(get_untyped(j, "Dagomba"));
+        x.set_draffy(get_untyped(j, "draffy"));
+        x.set_foreigner(get_untyped(j, "foreigner"));
+        x.set_guyandot(get_untyped(j, "Guyandot"));
+        x.set_neurogliosis(get_untyped(j, "neurogliosis"));
+        x.set_osmious(get_untyped(j, "osmious"));
+        x.set_palpitate(get_untyped(j, "palpitate"));
+        x.set_rebukeable(get_untyped(j, "rebukeable"));
+        x.set_reinwardtia(get_untyped(j, "Reinwardtia"));
+        x.set_reservatory(get_untyped(j, "reservatory"));
+        x.set_scalt(get_untyped(j, "scalt"));
+        x.set_scripturalize(get_untyped(j, "scripturalize"));
+        x.set_tintometer(get_untyped(j, "tintometer"));
+        x.set_tritoness(get_untyped(j, "Tritoness"));
+        x.set_undergrade(get_untyped(j, "undergrade"));
+        x.set_undermountain(get_untyped(j, "undermountain"));
+    }
+
+    inline void to_json(json & j, FenkClass const & x) {
+        j = json::object();
+        j["apoise"] = x.get_apoise();
+        j["astronomize"] = x.get_astronomize();
+        j["cockhorse"] = x.get_cockhorse();
+        j["copular"] = x.get_copular();
+        j["Dagomba"] = x.get_dagomba();
+        j["draffy"] = x.get_draffy();
+        j["foreigner"] = x.get_foreigner();
+        j["Guyandot"] = x.get_guyandot();
+        j["neurogliosis"] = x.get_neurogliosis();
+        j["osmious"] = x.get_osmious();
+        j["palpitate"] = x.get_palpitate();
+        j["rebukeable"] = x.get_rebukeable();
+        j["Reinwardtia"] = x.get_reinwardtia();
+        j["reservatory"] = x.get_reservatory();
+        j["scalt"] = x.get_scalt();
+        j["scripturalize"] = x.get_scripturalize();
+        j["tintometer"] = x.get_tintometer();
+        j["Tritoness"] = x.get_tritoness();
+        j["undergrade"] = x.get_undergrade();
+        j["undermountain"] = x.get_undermountain();
+    }
+
+    inline void from_json(json const & j, FlagmakingClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_albarco(get_untyped(j, "albarco"));
+        x.set_bunodonta(get_untyped(j, "Bunodonta"));
+        x.set_hornify(get_untyped(j, "hornify"));
+        x.set_hydrocorisae(get_untyped(j, "Hydrocorisae"));
+        x.set_hypoglossus(get_untyped(j, "hypoglossus"));
+        x.set_inexpiably(get_untyped(j, "inexpiably"));
+        x.set_ingratitude(get_untyped(j, "ingratitude"));
+        x.set_ladyfly(get_untyped(j, "ladyfly"));
+        x.set_medicament(get_untyped(j, "medicament"));
+        x.set_monogrammatic(get_untyped(j, "monogrammatic"));
+        x.set_nobbut(get_untyped(j, "nobbut"));
+        x.set_notacanthidae(get_untyped(j, "Notacanthidae"));
+        x.set_polyplacophore(get_untyped(j, "polyplacophore"));
+        x.set_proexercise(get_untyped(j, "proexercise"));
+        x.set_protoplast(get_untyped(j, "protoplast"));
+        x.set_puzzling(get_untyped(j, "puzzling"));
+        x.set_splanchnoskeleton(get_untyped(j, "splanchnoskeleton"));
+        x.set_unloveliness(get_untyped(j, "unloveliness"));
+        x.set_unquarantined(get_untyped(j, "unquarantined"));
+        x.set_unrenounceable(get_untyped(j, "unrenounceable"));
+    }
+
+    inline void to_json(json & j, FlagmakingClass const & x) {
+        j = json::object();
+        j["albarco"] = x.get_albarco();
+        j["Bunodonta"] = x.get_bunodonta();
+        j["hornify"] = x.get_hornify();
+        j["Hydrocorisae"] = x.get_hydrocorisae();
+        j["hypoglossus"] = x.get_hypoglossus();
+        j["inexpiably"] = x.get_inexpiably();
+        j["ingratitude"] = x.get_ingratitude();
+        j["ladyfly"] = x.get_ladyfly();
+        j["medicament"] = x.get_medicament();
+        j["monogrammatic"] = x.get_monogrammatic();
+        j["nobbut"] = x.get_nobbut();
+        j["Notacanthidae"] = x.get_notacanthidae();
+        j["polyplacophore"] = x.get_polyplacophore();
+        j["proexercise"] = x.get_proexercise();
+        j["protoplast"] = x.get_protoplast();
+        j["puzzling"] = x.get_puzzling();
+        j["splanchnoskeleton"] = x.get_splanchnoskeleton();
+        j["unloveliness"] = x.get_unloveliness();
+        j["unquarantined"] = x.get_unquarantined();
+        j["unrenounceable"] = x.get_unrenounceable();
+    }
+
+    inline void from_json(json const & j, HemocoeleClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acrogamy(get_untyped(j, "acrogamy"));
+        x.set_amelification(get_untyped(j, "amelification"));
+        x.set_autobiographic(get_untyped(j, "autobiographic"));
+        x.set_berat(get_untyped(j, "berat"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_disproportionably(get_untyped(j, "disproportionably"));
+        x.set_erythrite(get_untyped(j, "erythrite"));
+        x.set_graphic(get_untyped(j, "graphic"));
+        x.set_hepatological(get_untyped(j, "hepatological"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_incommensurably(get_untyped(j, "incommensurably"));
+        x.set_misaffirm(get_untyped(j, "misaffirm"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_pocketbook(get_untyped(j, "pocketbook"));
+        x.set_sclerometric(get_untyped(j, "sclerometric"));
+        x.set_stambouline(get_untyped(j, "stambouline"));
+        x.set_stickpin(get_untyped(j, "stickpin"));
+        x.set_tubulure(get_untyped(j, "tubulure"));
+        x.set_undelated(get_untyped(j, "undelated"));
+        x.set_unsalt(get_untyped(j, "unsalt"));
+        x.set_untutelar(get_untyped(j, "untutelar"));
+        x.set_vagrant(get_untyped(j, "vagrant"));
+        x.set_walt(get_untyped(j, "Walt"));
+    }
+
+    inline void to_json(json & j, HemocoeleClass const & x) {
+        j = json::object();
+        j["acrogamy"] = x.get_acrogamy();
+        j["amelification"] = x.get_amelification();
+        j["autobiographic"] = x.get_autobiographic();
+        j["berat"] = x.get_berat();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["disproportionably"] = x.get_disproportionably();
+        j["erythrite"] = x.get_erythrite();
+        j["graphic"] = x.get_graphic();
+        j["hepatological"] = x.get_hepatological();
+        j["homocerc"] = x.get_homocerc();
+        j["incommensurably"] = x.get_incommensurably();
+        j["misaffirm"] = x.get_misaffirm();
+        j["nonbookish"] = x.get_nonbookish();
+        j["pocketbook"] = x.get_pocketbook();
+        j["sclerometric"] = x.get_sclerometric();
+        j["stambouline"] = x.get_stambouline();
+        j["stickpin"] = x.get_stickpin();
+        j["tubulure"] = x.get_tubulure();
+        j["undelated"] = x.get_undelated();
+        j["unsalt"] = x.get_unsalt();
+        j["untutelar"] = x.get_untutelar();
+        j["vagrant"] = x.get_vagrant();
+        j["Walt"] = x.get_walt();
+    }
+
+    inline void from_json(json const & j, Interacinar& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_assapan(j.at("assapan").get<double>());
+        x.set_benefactorship(j.at("benefactorship").get<bool>());
+        x.set_triseriatim(j.at("triseriatim").get<std::string>());
+        x.set_tubbing(j.at("tubbing").get<int64_t>());
+        x.set_untrimmed(get_untyped(j, "untrimmed"));
+    }
+
+    inline void to_json(json & j, Interacinar const & x) {
+        j = json::object();
+        j["assapan"] = x.get_assapan();
+        j["benefactorship"] = x.get_benefactorship();
+        j["triseriatim"] = x.get_triseriatim();
+        j["tubbing"] = x.get_tubbing();
+        j["untrimmed"] = x.get_untrimmed();
+    }
+
+    inline void from_json(json const & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_centrodesmose(j.at("centrodesmose").get<std::string>());
+        x.set_cerograph(j.at("cerograph").get<std::vector<CerographElement>>());
+        x.set_chemotherapeutics(j.at("chemotherapeutics").get<std::vector<ChemotherapeuticElement>>());
+        x.set_cimelia(j.at("cimelia").get<std::vector<CimeliaElement>>());
+        x.set_citrated(j.at("citrated").get<int64_t>());
+        x.set_clinodome(j.at("clinodome").get<std::vector<Clinodome>>());
+        x.set_coadjust(j.at("coadjust").get<std::vector<CoadjustElement>>());
+        x.set_consilience(j.at("consilience").get<std::vector<Consilience>>());
+        x.set_constructor(j.at("constructor").get<std::vector<Constructor>>());
+        x.set_continuative(j.at("continuative").get<std::vector<Continuative>>());
+        x.set_credulity(j.at("credulity").get<std::vector<CredulityElement>>());
+        x.set_creviced(j.at("creviced").get<std::vector<Creviced>>());
+        x.set_cubiculum(j.at("cubiculum").get<std::vector<std::vector<std::optional<int64_t>>>>());
+        x.set_deruralize(j.at("deruralize").get<std::vector<DeruralizeElement>>());
+        x.set_diaereses(j.at("diaereses").get<std::vector<DiaereseElement>>());
+        x.set_dissolution(j.at("dissolution").get<std::vector<std::optional<std::vector<nlohmann::json>>>>());
+        x.set_downstroke(j.at("downstroke").get<std::vector<Downstroke>>());
+        x.set_electrotautomerism(j.at("electrotautomerism").get<std::vector<std::optional<double>>>());
+        x.set_eleutheromania(j.at("eleutheromania").get<std::vector<Eleutheromania>>());
+        x.set_encrust(j.at("encrust").get<Encrust>());
+        x.set_entomoid(j.at("entomoid").get<std::vector<Entomoid>>());
+        x.set_epipaleolithic(j.at("epipaleolithic").get<std::vector<Epipaleolithic>>());
+        x.set_expropriable(j.at("expropriable").get<std::vector<Expropriable>>());
+        x.set_faggingly(j.at("faggingly").get<std::vector<FagginglyElement>>());
+        x.set_fenks(j.at("fenks").get<std::vector<FenkElement>>());
+        x.set_flagmaking(j.at("flagmaking").get<std::vector<FlagmakingElement>>());
+        x.set_fluorometer(j.at("fluorometer").get<std::vector<Fluorometer>>());
+        x.set_fulsome(j.at("fulsome").get<std::vector<std::optional<int64_t>>>());
+        x.set_fuzzy(j.at("fuzzy").get<std::vector<Fuzzy>>());
+        x.set_gardenwards(j.at("gardenwards").get<std::vector<Gardenward>>());
+        x.set_generalissimo(j.at("generalissimo").get<std::vector<Generalissimo>>());
+        x.set_habeas(j.at("habeas").get<std::vector<std::optional<std::map<std::string, int64_t>>>>());
+        x.set_hemicrystalline(j.at("hemicrystalline").get<std::vector<Hemicrystalline>>());
+        x.set_hemocoele(j.at("hemocoele").get<std::vector<HemocoeleElement>>());
+        x.set_hoister(j.at("hoister").get<std::vector<Hoister>>());
+        x.set_hyperpiesis(j.at("hyperpiesis").get<std::vector<Hyperpiesi>>());
+        x.set_hyppish(j.at("hyppish").get<std::vector<Hyppish>>());
+        x.set_idealizer(j.at("idealizer").get<std::vector<Idealizer>>());
+        x.set_incrustator(j.at("incrustator").get<std::vector<Incrustator>>());
+        x.set_intentiveness(j.at("intentiveness").get<std::vector<Intentiveness>>());
+        x.set_interacinar(j.at("interacinar").get<Interacinar>());
+        x.set_intercorrelation(j.at("intercorrelation").get<std::vector<std::optional<std::vector<int64_t>>>>());
+        x.set_jacutinga(j.at("jacutinga").get<std::vector<Jacutinga>>());
+    }
+
+    inline void to_json(json & j, TopLevel const & x) {
+        j = json::object();
+        j["centrodesmose"] = x.get_centrodesmose();
+        j["cerograph"] = x.get_cerograph();
+        j["chemotherapeutics"] = x.get_chemotherapeutics();
+        j["cimelia"] = x.get_cimelia();
+        j["citrated"] = x.get_citrated();
+        j["clinodome"] = x.get_clinodome();
+        j["coadjust"] = x.get_coadjust();
+        j["consilience"] = x.get_consilience();
+        j["constructor"] = x.get_constructor();
+        j["continuative"] = x.get_continuative();
+        j["credulity"] = x.get_credulity();
+        j["creviced"] = x.get_creviced();
+        j["cubiculum"] = x.get_cubiculum();
+        j["deruralize"] = x.get_deruralize();
+        j["diaereses"] = x.get_diaereses();
+        j["dissolution"] = x.get_dissolution();
+        j["downstroke"] = x.get_downstroke();
+        j["electrotautomerism"] = x.get_electrotautomerism();
+        j["eleutheromania"] = x.get_eleutheromania();
+        j["encrust"] = x.get_encrust();
+        j["entomoid"] = x.get_entomoid();
+        j["epipaleolithic"] = x.get_epipaleolithic();
+        j["expropriable"] = x.get_expropriable();
+        j["faggingly"] = x.get_faggingly();
+        j["fenks"] = x.get_fenks();
+        j["flagmaking"] = x.get_flagmaking();
+        j["fluorometer"] = x.get_fluorometer();
+        j["fulsome"] = x.get_fulsome();
+        j["fuzzy"] = x.get_fuzzy();
+        j["gardenwards"] = x.get_gardenwards();
+        j["generalissimo"] = x.get_generalissimo();
+        j["habeas"] = x.get_habeas();
+        j["hemicrystalline"] = x.get_hemicrystalline();
+        j["hemocoele"] = x.get_hemocoele();
+        j["hoister"] = x.get_hoister();
+        j["hyperpiesis"] = x.get_hyperpiesis();
+        j["hyppish"] = x.get_hyppish();
+        j["idealizer"] = x.get_idealizer();
+        j["incrustator"] = x.get_incrustator();
+        j["intentiveness"] = x.get_intentiveness();
+        j["interacinar"] = x.get_interacinar();
+        j["intercorrelation"] = x.get_intercorrelation();
+        j["jacutinga"] = x.get_jacutinga();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<quicktype::CerographClass, std::string>>::from_json(json const & j, std::variant<quicktype::CerographClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CerographClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CerographClass, std::string>>::to_json(json & j, std::variant<quicktype::CerographClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CerographClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>>::from_json(json const & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::ChemotherapeuticClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>>::to_json(json & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ChemotherapeuticClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(json const & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, std::variant<double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoadjustClass, double>>::from_json(json const & j, std::variant<quicktype::CoadjustClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CoadjustClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoadjustClass, double>>::to_json(json & j, std::variant<quicktype::CoadjustClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CoadjustClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<double, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>>::from_json(json const & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>>::from_json(json const & j, std::variant<quicktype::CredulityClass, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CredulityClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>>::to_json(json & j, std::variant<quicktype::CredulityClass, int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CredulityClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<bool, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<bool, std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>>::from_json(json const & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::DeruralizeClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>>::to_json(json & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::DeruralizeClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::DiaereseClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>>::to_json(json & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::DiaereseClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::string>>::from_json(json const & j, std::variant<std::vector<json>, bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::string>>::to_json(json & j, std::variant<std::vector<json>, bool, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<double, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<double, std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>>::from_json(json const & j, std::variant<quicktype::CimeliaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>>::to_json(json & j, std::variant<quicktype::CimeliaClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(json const & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, std::variant<std::vector<int64_t>, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>>::to_json(json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FagginglyClass, double>>::from_json(json const & j, std::variant<quicktype::FagginglyClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FagginglyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FagginglyClass, double>>::to_json(json & j, std::variant<quicktype::FagginglyClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FagginglyClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FenkClass, std::string>>::from_json(json const & j, std::variant<quicktype::FenkClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::FenkClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FenkClass, std::string>>::to_json(json & j, std::variant<quicktype::FenkClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FenkClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>>::from_json(json const & j, std::variant<bool, quicktype::FlagmakingClass, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FlagmakingClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>>::to_json(json & j, std::variant<bool, quicktype::FlagmakingClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::FlagmakingClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::from_json(json const & j, std::variant<int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::to_json(json & j, std::variant<int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>>::from_json(json const & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, bool, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<bool, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, std::string>>::from_json(json const & j, std::variant<quicktype::CimeliaClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, std::string>>::to_json(json & j, std::variant<quicktype::CimeliaClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::HemocoeleClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::HemocoeleClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::CimeliaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>>::to_json(json & j, std::variant<std::vector<json>, quicktype::CimeliaClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::from_json(json const & j, std::variant<bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::to_json(json & j, std::variant<bool, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>>::to_json(json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>>::from_json(json const & j, std::variant<quicktype::CimeliaClass, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>>::to_json(json & j, std::variant<quicktype::CimeliaClass, double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>>::from_json(json const & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations1.json/default/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations1.json/default/quicktype.hpp
new file mode 100644
index 0000000..37097f3
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations1.json/default/quicktype.hpp
@@ -0,0 +1,3350 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    class CerographClass {
+        public:
+        CerographClass() = default;
+        virtual ~CerographClass() = default;
+
+        private:
+        nlohmann::json apotropaion;
+        nlohmann::json casuary;
+        nlohmann::json creaker;
+        nlohmann::json disqualification;
+        nlohmann::json imperatorious;
+        nlohmann::json impermeabilize;
+        nlohmann::json metastoma;
+        nlohmann::json noctidiurnal;
+        nlohmann::json nonreserve;
+        nlohmann::json ophthalmotonometry;
+        nlohmann::json pailful;
+        nlohmann::json pigfish;
+        nlohmann::json pongee;
+        nlohmann::json prosodical;
+        nlohmann::json scrofuloderm;
+        nlohmann::json storekeeping;
+        nlohmann::json therologist;
+        nlohmann::json tolowa;
+        nlohmann::json tradeful;
+        nlohmann::json unriveting;
+
+        public:
+        const nlohmann::json & get_apotropaion() const { return apotropaion; }
+        nlohmann::json & get_mutable_apotropaion() { return apotropaion; }
+        void set_apotropaion(const nlohmann::json & value) { this->apotropaion = value; }
+
+        const nlohmann::json & get_casuary() const { return casuary; }
+        nlohmann::json & get_mutable_casuary() { return casuary; }
+        void set_casuary(const nlohmann::json & value) { this->casuary = value; }
+
+        const nlohmann::json & get_creaker() const { return creaker; }
+        nlohmann::json & get_mutable_creaker() { return creaker; }
+        void set_creaker(const nlohmann::json & value) { this->creaker = value; }
+
+        const nlohmann::json & get_disqualification() const { return disqualification; }
+        nlohmann::json & get_mutable_disqualification() { return disqualification; }
+        void set_disqualification(const nlohmann::json & value) { this->disqualification = value; }
+
+        const nlohmann::json & get_imperatorious() const { return imperatorious; }
+        nlohmann::json & get_mutable_imperatorious() { return imperatorious; }
+        void set_imperatorious(const nlohmann::json & value) { this->imperatorious = value; }
+
+        const nlohmann::json & get_impermeabilize() const { return impermeabilize; }
+        nlohmann::json & get_mutable_impermeabilize() { return impermeabilize; }
+        void set_impermeabilize(const nlohmann::json & value) { this->impermeabilize = value; }
+
+        const nlohmann::json & get_metastoma() const { return metastoma; }
+        nlohmann::json & get_mutable_metastoma() { return metastoma; }
+        void set_metastoma(const nlohmann::json & value) { this->metastoma = value; }
+
+        const nlohmann::json & get_noctidiurnal() const { return noctidiurnal; }
+        nlohmann::json & get_mutable_noctidiurnal() { return noctidiurnal; }
+        void set_noctidiurnal(const nlohmann::json & value) { this->noctidiurnal = value; }
+
+        const nlohmann::json & get_nonreserve() const { return nonreserve; }
+        nlohmann::json & get_mutable_nonreserve() { return nonreserve; }
+        void set_nonreserve(const nlohmann::json & value) { this->nonreserve = value; }
+
+        const nlohmann::json & get_ophthalmotonometry() const { return ophthalmotonometry; }
+        nlohmann::json & get_mutable_ophthalmotonometry() { return ophthalmotonometry; }
+        void set_ophthalmotonometry(const nlohmann::json & value) { this->ophthalmotonometry = value; }
+
+        const nlohmann::json & get_pailful() const { return pailful; }
+        nlohmann::json & get_mutable_pailful() { return pailful; }
+        void set_pailful(const nlohmann::json & value) { this->pailful = value; }
+
+        const nlohmann::json & get_pigfish() const { return pigfish; }
+        nlohmann::json & get_mutable_pigfish() { return pigfish; }
+        void set_pigfish(const nlohmann::json & value) { this->pigfish = value; }
+
+        const nlohmann::json & get_pongee() const { return pongee; }
+        nlohmann::json & get_mutable_pongee() { return pongee; }
+        void set_pongee(const nlohmann::json & value) { this->pongee = value; }
+
+        const nlohmann::json & get_prosodical() const { return prosodical; }
+        nlohmann::json & get_mutable_prosodical() { return prosodical; }
+        void set_prosodical(const nlohmann::json & value) { this->prosodical = value; }
+
+        const nlohmann::json & get_scrofuloderm() const { return scrofuloderm; }
+        nlohmann::json & get_mutable_scrofuloderm() { return scrofuloderm; }
+        void set_scrofuloderm(const nlohmann::json & value) { this->scrofuloderm = value; }
+
+        const nlohmann::json & get_storekeeping() const { return storekeeping; }
+        nlohmann::json & get_mutable_storekeeping() { return storekeeping; }
+        void set_storekeeping(const nlohmann::json & value) { this->storekeeping = value; }
+
+        const nlohmann::json & get_therologist() const { return therologist; }
+        nlohmann::json & get_mutable_therologist() { return therologist; }
+        void set_therologist(const nlohmann::json & value) { this->therologist = value; }
+
+        const nlohmann::json & get_tolowa() const { return tolowa; }
+        nlohmann::json & get_mutable_tolowa() { return tolowa; }
+        void set_tolowa(const nlohmann::json & value) { this->tolowa = value; }
+
+        const nlohmann::json & get_tradeful() const { return tradeful; }
+        nlohmann::json & get_mutable_tradeful() { return tradeful; }
+        void set_tradeful(const nlohmann::json & value) { this->tradeful = value; }
+
+        const nlohmann::json & get_unriveting() const { return unriveting; }
+        nlohmann::json & get_mutable_unriveting() { return unriveting; }
+        void set_unriveting(const nlohmann::json & value) { this->unriveting = value; }
+    };
+
+    using CerographElement = std::optional<std::variant<CerographClass, std::string>>;
+
+    class ChemotherapeuticClass {
+        public:
+        ChemotherapeuticClass() = default;
+        virtual ~ChemotherapeuticClass() = default;
+
+        private:
+        nlohmann::json angioneurotic;
+        nlohmann::json availment;
+        nlohmann::json bladelet;
+        std::optional<double> catharticalness;
+        nlohmann::json caulis;
+        nlohmann::json chalcus;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enteradenological;
+        std::optional<bool> homocerc;
+        nlohmann::json imporosity;
+        nlohmann::json insistently;
+        nlohmann::json intraparietal;
+        nlohmann::json ivied;
+        nlohmann::json maureen;
+        nlohmann::json nonbookish;
+        nlohmann::json nostochine;
+        nlohmann::json nutcracker;
+        nlohmann::json ofttimes;
+        nlohmann::json phenocryst;
+        nlohmann::json precoincident;
+        nlohmann::json ramiferous;
+        nlohmann::json stagmometer;
+        nlohmann::json tetherball;
+        nlohmann::json unshy;
+
+        public:
+        const nlohmann::json & get_angioneurotic() const { return angioneurotic; }
+        nlohmann::json & get_mutable_angioneurotic() { return angioneurotic; }
+        void set_angioneurotic(const nlohmann::json & value) { this->angioneurotic = value; }
+
+        const nlohmann::json & get_availment() const { return availment; }
+        nlohmann::json & get_mutable_availment() { return availment; }
+        void set_availment(const nlohmann::json & value) { this->availment = value; }
+
+        const nlohmann::json & get_bladelet() const { return bladelet; }
+        nlohmann::json & get_mutable_bladelet() { return bladelet; }
+        void set_bladelet(const nlohmann::json & value) { this->bladelet = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const nlohmann::json & get_caulis() const { return caulis; }
+        nlohmann::json & get_mutable_caulis() { return caulis; }
+        void set_caulis(const nlohmann::json & value) { this->caulis = value; }
+
+        const nlohmann::json & get_chalcus() const { return chalcus; }
+        nlohmann::json & get_mutable_chalcus() { return chalcus; }
+        void set_chalcus(const nlohmann::json & value) { this->chalcus = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_enteradenological() const { return enteradenological; }
+        nlohmann::json & get_mutable_enteradenological() { return enteradenological; }
+        void set_enteradenological(const nlohmann::json & value) { this->enteradenological = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_imporosity() const { return imporosity; }
+        nlohmann::json & get_mutable_imporosity() { return imporosity; }
+        void set_imporosity(const nlohmann::json & value) { this->imporosity = value; }
+
+        const nlohmann::json & get_insistently() const { return insistently; }
+        nlohmann::json & get_mutable_insistently() { return insistently; }
+        void set_insistently(const nlohmann::json & value) { this->insistently = value; }
+
+        const nlohmann::json & get_intraparietal() const { return intraparietal; }
+        nlohmann::json & get_mutable_intraparietal() { return intraparietal; }
+        void set_intraparietal(const nlohmann::json & value) { this->intraparietal = value; }
+
+        const nlohmann::json & get_ivied() const { return ivied; }
+        nlohmann::json & get_mutable_ivied() { return ivied; }
+        void set_ivied(const nlohmann::json & value) { this->ivied = value; }
+
+        const nlohmann::json & get_maureen() const { return maureen; }
+        nlohmann::json & get_mutable_maureen() { return maureen; }
+        void set_maureen(const nlohmann::json & value) { this->maureen = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_nostochine() const { return nostochine; }
+        nlohmann::json & get_mutable_nostochine() { return nostochine; }
+        void set_nostochine(const nlohmann::json & value) { this->nostochine = value; }
+
+        const nlohmann::json & get_nutcracker() const { return nutcracker; }
+        nlohmann::json & get_mutable_nutcracker() { return nutcracker; }
+        void set_nutcracker(const nlohmann::json & value) { this->nutcracker = value; }
+
+        const nlohmann::json & get_ofttimes() const { return ofttimes; }
+        nlohmann::json & get_mutable_ofttimes() { return ofttimes; }
+        void set_ofttimes(const nlohmann::json & value) { this->ofttimes = value; }
+
+        const nlohmann::json & get_phenocryst() const { return phenocryst; }
+        nlohmann::json & get_mutable_phenocryst() { return phenocryst; }
+        void set_phenocryst(const nlohmann::json & value) { this->phenocryst = value; }
+
+        const nlohmann::json & get_precoincident() const { return precoincident; }
+        nlohmann::json & get_mutable_precoincident() { return precoincident; }
+        void set_precoincident(const nlohmann::json & value) { this->precoincident = value; }
+
+        const nlohmann::json & get_ramiferous() const { return ramiferous; }
+        nlohmann::json & get_mutable_ramiferous() { return ramiferous; }
+        void set_ramiferous(const nlohmann::json & value) { this->ramiferous = value; }
+
+        const nlohmann::json & get_stagmometer() const { return stagmometer; }
+        nlohmann::json & get_mutable_stagmometer() { return stagmometer; }
+        void set_stagmometer(const nlohmann::json & value) { this->stagmometer = value; }
+
+        const nlohmann::json & get_tetherball() const { return tetherball; }
+        nlohmann::json & get_mutable_tetherball() { return tetherball; }
+        void set_tetherball(const nlohmann::json & value) { this->tetherball = value; }
+
+        const nlohmann::json & get_unshy() const { return unshy; }
+        nlohmann::json & get_mutable_unshy() { return unshy; }
+        void set_unshy(const nlohmann::json & value) { this->unshy = value; }
+    };
+
+    using ChemotherapeuticElement = std::variant<ChemotherapeuticClass, int64_t>;
+
+    class CimeliaClass {
+        public:
+        CimeliaClass() = default;
+        virtual ~CimeliaClass() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        const double & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const double & value) { this->catharticalness = value; }
+
+        const int64_t & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const int64_t & value) { this->chirotherium = value; }
+
+        const std::string & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::string & value) { this->disdiapason = value; }
+
+        const bool & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const bool & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+    };
+
+    using CimeliaElement = std::optional<std::variant<std::vector<int64_t>, CimeliaClass>>;
+
+    using Clinodome = std::variant<double, std::string>;
+
+    class CoadjustClass {
+        public:
+        CoadjustClass() = default;
+        virtual ~CoadjustClass() = default;
+
+        private:
+        nlohmann::json amidosulphonal;
+        nlohmann::json benny;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json ensnare;
+        std::optional<bool> homocerc;
+        nlohmann::json hybridizer;
+        nlohmann::json leastwise;
+        nlohmann::json lof;
+        nlohmann::json monkhood;
+        nlohmann::json netherlandish;
+        nlohmann::json nonbookish;
+        nlohmann::json peonism;
+        nlohmann::json phonelescope;
+        nlohmann::json porphyrogeniture;
+        nlohmann::json preindemnify;
+        nlohmann::json rosal;
+        nlohmann::json scalenous;
+        nlohmann::json scopine;
+        nlohmann::json sedaceae;
+        nlohmann::json suberinize;
+        nlohmann::json symbiot;
+        nlohmann::json tablefellow;
+        nlohmann::json unchargeable;
+
+        public:
+        const nlohmann::json & get_amidosulphonal() const { return amidosulphonal; }
+        nlohmann::json & get_mutable_amidosulphonal() { return amidosulphonal; }
+        void set_amidosulphonal(const nlohmann::json & value) { this->amidosulphonal = value; }
+
+        const nlohmann::json & get_benny() const { return benny; }
+        nlohmann::json & get_mutable_benny() { return benny; }
+        void set_benny(const nlohmann::json & value) { this->benny = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_ensnare() const { return ensnare; }
+        nlohmann::json & get_mutable_ensnare() { return ensnare; }
+        void set_ensnare(const nlohmann::json & value) { this->ensnare = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_hybridizer() const { return hybridizer; }
+        nlohmann::json & get_mutable_hybridizer() { return hybridizer; }
+        void set_hybridizer(const nlohmann::json & value) { this->hybridizer = value; }
+
+        const nlohmann::json & get_leastwise() const { return leastwise; }
+        nlohmann::json & get_mutable_leastwise() { return leastwise; }
+        void set_leastwise(const nlohmann::json & value) { this->leastwise = value; }
+
+        const nlohmann::json & get_lof() const { return lof; }
+        nlohmann::json & get_mutable_lof() { return lof; }
+        void set_lof(const nlohmann::json & value) { this->lof = value; }
+
+        const nlohmann::json & get_monkhood() const { return monkhood; }
+        nlohmann::json & get_mutable_monkhood() { return monkhood; }
+        void set_monkhood(const nlohmann::json & value) { this->monkhood = value; }
+
+        const nlohmann::json & get_netherlandish() const { return netherlandish; }
+        nlohmann::json & get_mutable_netherlandish() { return netherlandish; }
+        void set_netherlandish(const nlohmann::json & value) { this->netherlandish = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_peonism() const { return peonism; }
+        nlohmann::json & get_mutable_peonism() { return peonism; }
+        void set_peonism(const nlohmann::json & value) { this->peonism = value; }
+
+        const nlohmann::json & get_phonelescope() const { return phonelescope; }
+        nlohmann::json & get_mutable_phonelescope() { return phonelescope; }
+        void set_phonelescope(const nlohmann::json & value) { this->phonelescope = value; }
+
+        const nlohmann::json & get_porphyrogeniture() const { return porphyrogeniture; }
+        nlohmann::json & get_mutable_porphyrogeniture() { return porphyrogeniture; }
+        void set_porphyrogeniture(const nlohmann::json & value) { this->porphyrogeniture = value; }
+
+        const nlohmann::json & get_preindemnify() const { return preindemnify; }
+        nlohmann::json & get_mutable_preindemnify() { return preindemnify; }
+        void set_preindemnify(const nlohmann::json & value) { this->preindemnify = value; }
+
+        const nlohmann::json & get_rosal() const { return rosal; }
+        nlohmann::json & get_mutable_rosal() { return rosal; }
+        void set_rosal(const nlohmann::json & value) { this->rosal = value; }
+
+        const nlohmann::json & get_scalenous() const { return scalenous; }
+        nlohmann::json & get_mutable_scalenous() { return scalenous; }
+        void set_scalenous(const nlohmann::json & value) { this->scalenous = value; }
+
+        const nlohmann::json & get_scopine() const { return scopine; }
+        nlohmann::json & get_mutable_scopine() { return scopine; }
+        void set_scopine(const nlohmann::json & value) { this->scopine = value; }
+
+        const nlohmann::json & get_sedaceae() const { return sedaceae; }
+        nlohmann::json & get_mutable_sedaceae() { return sedaceae; }
+        void set_sedaceae(const nlohmann::json & value) { this->sedaceae = value; }
+
+        const nlohmann::json & get_suberinize() const { return suberinize; }
+        nlohmann::json & get_mutable_suberinize() { return suberinize; }
+        void set_suberinize(const nlohmann::json & value) { this->suberinize = value; }
+
+        const nlohmann::json & get_symbiot() const { return symbiot; }
+        nlohmann::json & get_mutable_symbiot() { return symbiot; }
+        void set_symbiot(const nlohmann::json & value) { this->symbiot = value; }
+
+        const nlohmann::json & get_tablefellow() const { return tablefellow; }
+        nlohmann::json & get_mutable_tablefellow() { return tablefellow; }
+        void set_tablefellow(const nlohmann::json & value) { this->tablefellow = value; }
+
+        const nlohmann::json & get_unchargeable() const { return unchargeable; }
+        nlohmann::json & get_mutable_unchargeable() { return unchargeable; }
+        void set_unchargeable(const nlohmann::json & value) { this->unchargeable = value; }
+    };
+
+    using CoadjustElement = std::variant<CoadjustClass, double>;
+
+    using Consilience = std::variant<double, std::map<std::string, int64_t>>;
+
+    using Constructor = std::variant<bool, std::map<std::string, std::optional<int64_t>>>;
+
+    using Continuative = std::variant<std::map<std::string, int64_t>, std::string>;
+
+    class CredulityClass {
+        public:
+        CredulityClass() = default;
+        virtual ~CredulityClass() = default;
+
+        private:
+        nlohmann::json ammonolytic;
+        nlohmann::json bushmaster;
+        nlohmann::json considering;
+        nlohmann::json consuetudinary;
+        nlohmann::json embarras;
+        nlohmann::json fineness;
+        nlohmann::json flaithship;
+        nlohmann::json flavia;
+        nlohmann::json gruffly;
+        nlohmann::json hedychium;
+        nlohmann::json leadwort;
+        nlohmann::json overseriously;
+        nlohmann::json parabola;
+        nlohmann::json pectinatodenticulate;
+        nlohmann::json popean;
+        nlohmann::json pornocrat;
+        nlohmann::json quadrisect;
+        nlohmann::json seriality;
+        nlohmann::json vamphorn;
+        nlohmann::json wharp;
+
+        public:
+        const nlohmann::json & get_ammonolytic() const { return ammonolytic; }
+        nlohmann::json & get_mutable_ammonolytic() { return ammonolytic; }
+        void set_ammonolytic(const nlohmann::json & value) { this->ammonolytic = value; }
+
+        const nlohmann::json & get_bushmaster() const { return bushmaster; }
+        nlohmann::json & get_mutable_bushmaster() { return bushmaster; }
+        void set_bushmaster(const nlohmann::json & value) { this->bushmaster = value; }
+
+        const nlohmann::json & get_considering() const { return considering; }
+        nlohmann::json & get_mutable_considering() { return considering; }
+        void set_considering(const nlohmann::json & value) { this->considering = value; }
+
+        const nlohmann::json & get_consuetudinary() const { return consuetudinary; }
+        nlohmann::json & get_mutable_consuetudinary() { return consuetudinary; }
+        void set_consuetudinary(const nlohmann::json & value) { this->consuetudinary = value; }
+
+        const nlohmann::json & get_embarras() const { return embarras; }
+        nlohmann::json & get_mutable_embarras() { return embarras; }
+        void set_embarras(const nlohmann::json & value) { this->embarras = value; }
+
+        const nlohmann::json & get_fineness() const { return fineness; }
+        nlohmann::json & get_mutable_fineness() { return fineness; }
+        void set_fineness(const nlohmann::json & value) { this->fineness = value; }
+
+        const nlohmann::json & get_flaithship() const { return flaithship; }
+        nlohmann::json & get_mutable_flaithship() { return flaithship; }
+        void set_flaithship(const nlohmann::json & value) { this->flaithship = value; }
+
+        const nlohmann::json & get_flavia() const { return flavia; }
+        nlohmann::json & get_mutable_flavia() { return flavia; }
+        void set_flavia(const nlohmann::json & value) { this->flavia = value; }
+
+        const nlohmann::json & get_gruffly() const { return gruffly; }
+        nlohmann::json & get_mutable_gruffly() { return gruffly; }
+        void set_gruffly(const nlohmann::json & value) { this->gruffly = value; }
+
+        const nlohmann::json & get_hedychium() const { return hedychium; }
+        nlohmann::json & get_mutable_hedychium() { return hedychium; }
+        void set_hedychium(const nlohmann::json & value) { this->hedychium = value; }
+
+        const nlohmann::json & get_leadwort() const { return leadwort; }
+        nlohmann::json & get_mutable_leadwort() { return leadwort; }
+        void set_leadwort(const nlohmann::json & value) { this->leadwort = value; }
+
+        const nlohmann::json & get_overseriously() const { return overseriously; }
+        nlohmann::json & get_mutable_overseriously() { return overseriously; }
+        void set_overseriously(const nlohmann::json & value) { this->overseriously = value; }
+
+        const nlohmann::json & get_parabola() const { return parabola; }
+        nlohmann::json & get_mutable_parabola() { return parabola; }
+        void set_parabola(const nlohmann::json & value) { this->parabola = value; }
+
+        const nlohmann::json & get_pectinatodenticulate() const { return pectinatodenticulate; }
+        nlohmann::json & get_mutable_pectinatodenticulate() { return pectinatodenticulate; }
+        void set_pectinatodenticulate(const nlohmann::json & value) { this->pectinatodenticulate = value; }
+
+        const nlohmann::json & get_popean() const { return popean; }
+        nlohmann::json & get_mutable_popean() { return popean; }
+        void set_popean(const nlohmann::json & value) { this->popean = value; }
+
+        const nlohmann::json & get_pornocrat() const { return pornocrat; }
+        nlohmann::json & get_mutable_pornocrat() { return pornocrat; }
+        void set_pornocrat(const nlohmann::json & value) { this->pornocrat = value; }
+
+        const nlohmann::json & get_quadrisect() const { return quadrisect; }
+        nlohmann::json & get_mutable_quadrisect() { return quadrisect; }
+        void set_quadrisect(const nlohmann::json & value) { this->quadrisect = value; }
+
+        const nlohmann::json & get_seriality() const { return seriality; }
+        nlohmann::json & get_mutable_seriality() { return seriality; }
+        void set_seriality(const nlohmann::json & value) { this->seriality = value; }
+
+        const nlohmann::json & get_vamphorn() const { return vamphorn; }
+        nlohmann::json & get_mutable_vamphorn() { return vamphorn; }
+        void set_vamphorn(const nlohmann::json & value) { this->vamphorn = value; }
+
+        const nlohmann::json & get_wharp() const { return wharp; }
+        nlohmann::json & get_mutable_wharp() { return wharp; }
+        void set_wharp(const nlohmann::json & value) { this->wharp = value; }
+    };
+
+    using CredulityElement = std::variant<CredulityClass, int64_t, std::string>;
+
+    using Creviced = std::variant<bool, std::map<std::string, int64_t>, std::string>;
+
+    class DeruralizeClass {
+        public:
+        DeruralizeClass() = default;
+        virtual ~DeruralizeClass() = default;
+
+        private:
+        nlohmann::json bockerel;
+        nlohmann::json boulder;
+        nlohmann::json churrus;
+        nlohmann::json counterdigged;
+        nlohmann::json dialogite;
+        nlohmann::json digenic;
+        nlohmann::json dunbird;
+        nlohmann::json ergatogyne;
+        nlohmann::json fiendful;
+        nlohmann::json jackrod;
+        nlohmann::json jehovistic;
+        nlohmann::json paninean;
+        nlohmann::json panther;
+        nlohmann::json placentigerous;
+        nlohmann::json romney;
+        nlohmann::json sparm;
+        nlohmann::json tocsin;
+        nlohmann::json unnicked;
+        nlohmann::json unstavable;
+        nlohmann::json windfirm;
+
+        public:
+        const nlohmann::json & get_bockerel() const { return bockerel; }
+        nlohmann::json & get_mutable_bockerel() { return bockerel; }
+        void set_bockerel(const nlohmann::json & value) { this->bockerel = value; }
+
+        const nlohmann::json & get_boulder() const { return boulder; }
+        nlohmann::json & get_mutable_boulder() { return boulder; }
+        void set_boulder(const nlohmann::json & value) { this->boulder = value; }
+
+        const nlohmann::json & get_churrus() const { return churrus; }
+        nlohmann::json & get_mutable_churrus() { return churrus; }
+        void set_churrus(const nlohmann::json & value) { this->churrus = value; }
+
+        const nlohmann::json & get_counterdigged() const { return counterdigged; }
+        nlohmann::json & get_mutable_counterdigged() { return counterdigged; }
+        void set_counterdigged(const nlohmann::json & value) { this->counterdigged = value; }
+
+        const nlohmann::json & get_dialogite() const { return dialogite; }
+        nlohmann::json & get_mutable_dialogite() { return dialogite; }
+        void set_dialogite(const nlohmann::json & value) { this->dialogite = value; }
+
+        const nlohmann::json & get_digenic() const { return digenic; }
+        nlohmann::json & get_mutable_digenic() { return digenic; }
+        void set_digenic(const nlohmann::json & value) { this->digenic = value; }
+
+        const nlohmann::json & get_dunbird() const { return dunbird; }
+        nlohmann::json & get_mutable_dunbird() { return dunbird; }
+        void set_dunbird(const nlohmann::json & value) { this->dunbird = value; }
+
+        const nlohmann::json & get_ergatogyne() const { return ergatogyne; }
+        nlohmann::json & get_mutable_ergatogyne() { return ergatogyne; }
+        void set_ergatogyne(const nlohmann::json & value) { this->ergatogyne = value; }
+
+        const nlohmann::json & get_fiendful() const { return fiendful; }
+        nlohmann::json & get_mutable_fiendful() { return fiendful; }
+        void set_fiendful(const nlohmann::json & value) { this->fiendful = value; }
+
+        const nlohmann::json & get_jackrod() const { return jackrod; }
+        nlohmann::json & get_mutable_jackrod() { return jackrod; }
+        void set_jackrod(const nlohmann::json & value) { this->jackrod = value; }
+
+        const nlohmann::json & get_jehovistic() const { return jehovistic; }
+        nlohmann::json & get_mutable_jehovistic() { return jehovistic; }
+        void set_jehovistic(const nlohmann::json & value) { this->jehovistic = value; }
+
+        const nlohmann::json & get_paninean() const { return paninean; }
+        nlohmann::json & get_mutable_paninean() { return paninean; }
+        void set_paninean(const nlohmann::json & value) { this->paninean = value; }
+
+        const nlohmann::json & get_panther() const { return panther; }
+        nlohmann::json & get_mutable_panther() { return panther; }
+        void set_panther(const nlohmann::json & value) { this->panther = value; }
+
+        const nlohmann::json & get_placentigerous() const { return placentigerous; }
+        nlohmann::json & get_mutable_placentigerous() { return placentigerous; }
+        void set_placentigerous(const nlohmann::json & value) { this->placentigerous = value; }
+
+        const nlohmann::json & get_romney() const { return romney; }
+        nlohmann::json & get_mutable_romney() { return romney; }
+        void set_romney(const nlohmann::json & value) { this->romney = value; }
+
+        const nlohmann::json & get_sparm() const { return sparm; }
+        nlohmann::json & get_mutable_sparm() { return sparm; }
+        void set_sparm(const nlohmann::json & value) { this->sparm = value; }
+
+        const nlohmann::json & get_tocsin() const { return tocsin; }
+        nlohmann::json & get_mutable_tocsin() { return tocsin; }
+        void set_tocsin(const nlohmann::json & value) { this->tocsin = value; }
+
+        const nlohmann::json & get_unnicked() const { return unnicked; }
+        nlohmann::json & get_mutable_unnicked() { return unnicked; }
+        void set_unnicked(const nlohmann::json & value) { this->unnicked = value; }
+
+        const nlohmann::json & get_unstavable() const { return unstavable; }
+        nlohmann::json & get_mutable_unstavable() { return unstavable; }
+        void set_unstavable(const nlohmann::json & value) { this->unstavable = value; }
+
+        const nlohmann::json & get_windfirm() const { return windfirm; }
+        nlohmann::json & get_mutable_windfirm() { return windfirm; }
+        void set_windfirm(const nlohmann::json & value) { this->windfirm = value; }
+    };
+
+    using DeruralizeElement = std::variant<std::vector<nlohmann::json>, bool, DeruralizeClass>;
+
+    class DiaereseClass {
+        public:
+        DiaereseClass() = default;
+        virtual ~DiaereseClass() = default;
+
+        private:
+        nlohmann::json amoreuxia;
+        nlohmann::json ani;
+        nlohmann::json bernicle;
+        nlohmann::json blackwasher;
+        nlohmann::json blowhard;
+        nlohmann::json broma;
+        nlohmann::json closecross;
+        nlohmann::json congregationalism;
+        nlohmann::json grayly;
+        nlohmann::json historically;
+        nlohmann::json hoast;
+        nlohmann::json irretentive;
+        nlohmann::json parcener;
+        nlohmann::json pedder;
+        nlohmann::json pseudoanatomic;
+        nlohmann::json rhizocarpian;
+        nlohmann::json samel;
+        nlohmann::json silker;
+        nlohmann::json subdentated;
+        nlohmann::json subobscure;
+
+        public:
+        const nlohmann::json & get_amoreuxia() const { return amoreuxia; }
+        nlohmann::json & get_mutable_amoreuxia() { return amoreuxia; }
+        void set_amoreuxia(const nlohmann::json & value) { this->amoreuxia = value; }
+
+        const nlohmann::json & get_ani() const { return ani; }
+        nlohmann::json & get_mutable_ani() { return ani; }
+        void set_ani(const nlohmann::json & value) { this->ani = value; }
+
+        const nlohmann::json & get_bernicle() const { return bernicle; }
+        nlohmann::json & get_mutable_bernicle() { return bernicle; }
+        void set_bernicle(const nlohmann::json & value) { this->bernicle = value; }
+
+        const nlohmann::json & get_blackwasher() const { return blackwasher; }
+        nlohmann::json & get_mutable_blackwasher() { return blackwasher; }
+        void set_blackwasher(const nlohmann::json & value) { this->blackwasher = value; }
+
+        const nlohmann::json & get_blowhard() const { return blowhard; }
+        nlohmann::json & get_mutable_blowhard() { return blowhard; }
+        void set_blowhard(const nlohmann::json & value) { this->blowhard = value; }
+
+        const nlohmann::json & get_broma() const { return broma; }
+        nlohmann::json & get_mutable_broma() { return broma; }
+        void set_broma(const nlohmann::json & value) { this->broma = value; }
+
+        const nlohmann::json & get_closecross() const { return closecross; }
+        nlohmann::json & get_mutable_closecross() { return closecross; }
+        void set_closecross(const nlohmann::json & value) { this->closecross = value; }
+
+        const nlohmann::json & get_congregationalism() const { return congregationalism; }
+        nlohmann::json & get_mutable_congregationalism() { return congregationalism; }
+        void set_congregationalism(const nlohmann::json & value) { this->congregationalism = value; }
+
+        const nlohmann::json & get_grayly() const { return grayly; }
+        nlohmann::json & get_mutable_grayly() { return grayly; }
+        void set_grayly(const nlohmann::json & value) { this->grayly = value; }
+
+        const nlohmann::json & get_historically() const { return historically; }
+        nlohmann::json & get_mutable_historically() { return historically; }
+        void set_historically(const nlohmann::json & value) { this->historically = value; }
+
+        const nlohmann::json & get_hoast() const { return hoast; }
+        nlohmann::json & get_mutable_hoast() { return hoast; }
+        void set_hoast(const nlohmann::json & value) { this->hoast = value; }
+
+        const nlohmann::json & get_irretentive() const { return irretentive; }
+        nlohmann::json & get_mutable_irretentive() { return irretentive; }
+        void set_irretentive(const nlohmann::json & value) { this->irretentive = value; }
+
+        const nlohmann::json & get_parcener() const { return parcener; }
+        nlohmann::json & get_mutable_parcener() { return parcener; }
+        void set_parcener(const nlohmann::json & value) { this->parcener = value; }
+
+        const nlohmann::json & get_pedder() const { return pedder; }
+        nlohmann::json & get_mutable_pedder() { return pedder; }
+        void set_pedder(const nlohmann::json & value) { this->pedder = value; }
+
+        const nlohmann::json & get_pseudoanatomic() const { return pseudoanatomic; }
+        nlohmann::json & get_mutable_pseudoanatomic() { return pseudoanatomic; }
+        void set_pseudoanatomic(const nlohmann::json & value) { this->pseudoanatomic = value; }
+
+        const nlohmann::json & get_rhizocarpian() const { return rhizocarpian; }
+        nlohmann::json & get_mutable_rhizocarpian() { return rhizocarpian; }
+        void set_rhizocarpian(const nlohmann::json & value) { this->rhizocarpian = value; }
+
+        const nlohmann::json & get_samel() const { return samel; }
+        nlohmann::json & get_mutable_samel() { return samel; }
+        void set_samel(const nlohmann::json & value) { this->samel = value; }
+
+        const nlohmann::json & get_silker() const { return silker; }
+        nlohmann::json & get_mutable_silker() { return silker; }
+        void set_silker(const nlohmann::json & value) { this->silker = value; }
+
+        const nlohmann::json & get_subdentated() const { return subdentated; }
+        nlohmann::json & get_mutable_subdentated() { return subdentated; }
+        void set_subdentated(const nlohmann::json & value) { this->subdentated = value; }
+
+        const nlohmann::json & get_subobscure() const { return subobscure; }
+        nlohmann::json & get_mutable_subobscure() { return subobscure; }
+        void set_subobscure(const nlohmann::json & value) { this->subobscure = value; }
+    };
+
+    using DiaereseElement = std::variant<std::vector<int64_t>, bool, DiaereseClass>;
+
+    using Downstroke = std::variant<std::vector<nlohmann::json>, bool, std::string>;
+
+    using Eleutheromania = std::variant<double, std::map<std::string, int64_t>, std::string>;
+
+    class Encrust {
+        public:
+        Encrust() = default;
+        virtual ~Encrust() = default;
+
+        private:
+        nlohmann::json comradely;
+        nlohmann::json diacanthous;
+        nlohmann::json feminineness;
+        nlohmann::json gossamered;
+        nlohmann::json hibernia;
+        nlohmann::json hibiscus;
+        nlohmann::json lepidosauria;
+        nlohmann::json lollingly;
+        nlohmann::json manager;
+        nlohmann::json mechanic;
+        nlohmann::json overminuteness;
+        nlohmann::json papelonne;
+        nlohmann::json plebification;
+        nlohmann::json pugmiller;
+        nlohmann::json recoveror;
+        nlohmann::json spermatoblastic;
+        nlohmann::json syllidae;
+        nlohmann::json ungyved;
+        nlohmann::json whirlabout;
+        nlohmann::json woodenware;
+
+        public:
+        const nlohmann::json & get_comradely() const { return comradely; }
+        nlohmann::json & get_mutable_comradely() { return comradely; }
+        void set_comradely(const nlohmann::json & value) { this->comradely = value; }
+
+        const nlohmann::json & get_diacanthous() const { return diacanthous; }
+        nlohmann::json & get_mutable_diacanthous() { return diacanthous; }
+        void set_diacanthous(const nlohmann::json & value) { this->diacanthous = value; }
+
+        const nlohmann::json & get_feminineness() const { return feminineness; }
+        nlohmann::json & get_mutable_feminineness() { return feminineness; }
+        void set_feminineness(const nlohmann::json & value) { this->feminineness = value; }
+
+        const nlohmann::json & get_gossamered() const { return gossamered; }
+        nlohmann::json & get_mutable_gossamered() { return gossamered; }
+        void set_gossamered(const nlohmann::json & value) { this->gossamered = value; }
+
+        const nlohmann::json & get_hibernia() const { return hibernia; }
+        nlohmann::json & get_mutable_hibernia() { return hibernia; }
+        void set_hibernia(const nlohmann::json & value) { this->hibernia = value; }
+
+        const nlohmann::json & get_hibiscus() const { return hibiscus; }
+        nlohmann::json & get_mutable_hibiscus() { return hibiscus; }
+        void set_hibiscus(const nlohmann::json & value) { this->hibiscus = value; }
+
+        const nlohmann::json & get_lepidosauria() const { return lepidosauria; }
+        nlohmann::json & get_mutable_lepidosauria() { return lepidosauria; }
+        void set_lepidosauria(const nlohmann::json & value) { this->lepidosauria = value; }
+
+        const nlohmann::json & get_lollingly() const { return lollingly; }
+        nlohmann::json & get_mutable_lollingly() { return lollingly; }
+        void set_lollingly(const nlohmann::json & value) { this->lollingly = value; }
+
+        const nlohmann::json & get_manager() const { return manager; }
+        nlohmann::json & get_mutable_manager() { return manager; }
+        void set_manager(const nlohmann::json & value) { this->manager = value; }
+
+        const nlohmann::json & get_mechanic() const { return mechanic; }
+        nlohmann::json & get_mutable_mechanic() { return mechanic; }
+        void set_mechanic(const nlohmann::json & value) { this->mechanic = value; }
+
+        const nlohmann::json & get_overminuteness() const { return overminuteness; }
+        nlohmann::json & get_mutable_overminuteness() { return overminuteness; }
+        void set_overminuteness(const nlohmann::json & value) { this->overminuteness = value; }
+
+        const nlohmann::json & get_papelonne() const { return papelonne; }
+        nlohmann::json & get_mutable_papelonne() { return papelonne; }
+        void set_papelonne(const nlohmann::json & value) { this->papelonne = value; }
+
+        const nlohmann::json & get_plebification() const { return plebification; }
+        nlohmann::json & get_mutable_plebification() { return plebification; }
+        void set_plebification(const nlohmann::json & value) { this->plebification = value; }
+
+        const nlohmann::json & get_pugmiller() const { return pugmiller; }
+        nlohmann::json & get_mutable_pugmiller() { return pugmiller; }
+        void set_pugmiller(const nlohmann::json & value) { this->pugmiller = value; }
+
+        const nlohmann::json & get_recoveror() const { return recoveror; }
+        nlohmann::json & get_mutable_recoveror() { return recoveror; }
+        void set_recoveror(const nlohmann::json & value) { this->recoveror = value; }
+
+        const nlohmann::json & get_spermatoblastic() const { return spermatoblastic; }
+        nlohmann::json & get_mutable_spermatoblastic() { return spermatoblastic; }
+        void set_spermatoblastic(const nlohmann::json & value) { this->spermatoblastic = value; }
+
+        const nlohmann::json & get_syllidae() const { return syllidae; }
+        nlohmann::json & get_mutable_syllidae() { return syllidae; }
+        void set_syllidae(const nlohmann::json & value) { this->syllidae = value; }
+
+        const nlohmann::json & get_ungyved() const { return ungyved; }
+        nlohmann::json & get_mutable_ungyved() { return ungyved; }
+        void set_ungyved(const nlohmann::json & value) { this->ungyved = value; }
+
+        const nlohmann::json & get_whirlabout() const { return whirlabout; }
+        nlohmann::json & get_mutable_whirlabout() { return whirlabout; }
+        void set_whirlabout(const nlohmann::json & value) { this->whirlabout = value; }
+
+        const nlohmann::json & get_woodenware() const { return woodenware; }
+        nlohmann::json & get_mutable_woodenware() { return woodenware; }
+        void set_woodenware(const nlohmann::json & value) { this->woodenware = value; }
+    };
+
+    using Entomoid = std::variant<CimeliaClass, int64_t>;
+
+    using Epipaleolithic = std::variant<std::vector<int64_t>, double>;
+
+    using Expropriable = std::variant<std::vector<nlohmann::json>, CimeliaClass, double>;
+
+    class FagginglyClass {
+        public:
+        FagginglyClass() = default;
+        virtual ~FagginglyClass() = default;
+
+        private:
+        nlohmann::json abranchian;
+        nlohmann::json aculeiform;
+        nlohmann::json adiaphoristic;
+        nlohmann::json adoptionism;
+        nlohmann::json anglic;
+        nlohmann::json antrotomy;
+        nlohmann::json coerciveness;
+        nlohmann::json decorist;
+        nlohmann::json duckhood;
+        nlohmann::json heteromeri;
+        nlohmann::json hypochnose;
+        nlohmann::json lochage;
+        nlohmann::json melee;
+        nlohmann::json nonconformitant;
+        nlohmann::json poinsettia;
+        nlohmann::json putatively;
+        nlohmann::json semivolatile;
+        nlohmann::json soleas;
+        nlohmann::json unfastenable;
+        nlohmann::json unmillinered;
+
+        public:
+        const nlohmann::json & get_abranchian() const { return abranchian; }
+        nlohmann::json & get_mutable_abranchian() { return abranchian; }
+        void set_abranchian(const nlohmann::json & value) { this->abranchian = value; }
+
+        const nlohmann::json & get_aculeiform() const { return aculeiform; }
+        nlohmann::json & get_mutable_aculeiform() { return aculeiform; }
+        void set_aculeiform(const nlohmann::json & value) { this->aculeiform = value; }
+
+        const nlohmann::json & get_adiaphoristic() const { return adiaphoristic; }
+        nlohmann::json & get_mutable_adiaphoristic() { return adiaphoristic; }
+        void set_adiaphoristic(const nlohmann::json & value) { this->adiaphoristic = value; }
+
+        const nlohmann::json & get_adoptionism() const { return adoptionism; }
+        nlohmann::json & get_mutable_adoptionism() { return adoptionism; }
+        void set_adoptionism(const nlohmann::json & value) { this->adoptionism = value; }
+
+        const nlohmann::json & get_anglic() const { return anglic; }
+        nlohmann::json & get_mutable_anglic() { return anglic; }
+        void set_anglic(const nlohmann::json & value) { this->anglic = value; }
+
+        const nlohmann::json & get_antrotomy() const { return antrotomy; }
+        nlohmann::json & get_mutable_antrotomy() { return antrotomy; }
+        void set_antrotomy(const nlohmann::json & value) { this->antrotomy = value; }
+
+        const nlohmann::json & get_coerciveness() const { return coerciveness; }
+        nlohmann::json & get_mutable_coerciveness() { return coerciveness; }
+        void set_coerciveness(const nlohmann::json & value) { this->coerciveness = value; }
+
+        const nlohmann::json & get_decorist() const { return decorist; }
+        nlohmann::json & get_mutable_decorist() { return decorist; }
+        void set_decorist(const nlohmann::json & value) { this->decorist = value; }
+
+        const nlohmann::json & get_duckhood() const { return duckhood; }
+        nlohmann::json & get_mutable_duckhood() { return duckhood; }
+        void set_duckhood(const nlohmann::json & value) { this->duckhood = value; }
+
+        const nlohmann::json & get_heteromeri() const { return heteromeri; }
+        nlohmann::json & get_mutable_heteromeri() { return heteromeri; }
+        void set_heteromeri(const nlohmann::json & value) { this->heteromeri = value; }
+
+        const nlohmann::json & get_hypochnose() const { return hypochnose; }
+        nlohmann::json & get_mutable_hypochnose() { return hypochnose; }
+        void set_hypochnose(const nlohmann::json & value) { this->hypochnose = value; }
+
+        const nlohmann::json & get_lochage() const { return lochage; }
+        nlohmann::json & get_mutable_lochage() { return lochage; }
+        void set_lochage(const nlohmann::json & value) { this->lochage = value; }
+
+        const nlohmann::json & get_melee() const { return melee; }
+        nlohmann::json & get_mutable_melee() { return melee; }
+        void set_melee(const nlohmann::json & value) { this->melee = value; }
+
+        const nlohmann::json & get_nonconformitant() const { return nonconformitant; }
+        nlohmann::json & get_mutable_nonconformitant() { return nonconformitant; }
+        void set_nonconformitant(const nlohmann::json & value) { this->nonconformitant = value; }
+
+        const nlohmann::json & get_poinsettia() const { return poinsettia; }
+        nlohmann::json & get_mutable_poinsettia() { return poinsettia; }
+        void set_poinsettia(const nlohmann::json & value) { this->poinsettia = value; }
+
+        const nlohmann::json & get_putatively() const { return putatively; }
+        nlohmann::json & get_mutable_putatively() { return putatively; }
+        void set_putatively(const nlohmann::json & value) { this->putatively = value; }
+
+        const nlohmann::json & get_semivolatile() const { return semivolatile; }
+        nlohmann::json & get_mutable_semivolatile() { return semivolatile; }
+        void set_semivolatile(const nlohmann::json & value) { this->semivolatile = value; }
+
+        const nlohmann::json & get_soleas() const { return soleas; }
+        nlohmann::json & get_mutable_soleas() { return soleas; }
+        void set_soleas(const nlohmann::json & value) { this->soleas = value; }
+
+        const nlohmann::json & get_unfastenable() const { return unfastenable; }
+        nlohmann::json & get_mutable_unfastenable() { return unfastenable; }
+        void set_unfastenable(const nlohmann::json & value) { this->unfastenable = value; }
+
+        const nlohmann::json & get_unmillinered() const { return unmillinered; }
+        nlohmann::json & get_mutable_unmillinered() { return unmillinered; }
+        void set_unmillinered(const nlohmann::json & value) { this->unmillinered = value; }
+    };
+
+    using FagginglyElement = std::variant<FagginglyClass, double>;
+
+    class FenkClass {
+        public:
+        FenkClass() = default;
+        virtual ~FenkClass() = default;
+
+        private:
+        nlohmann::json apoise;
+        nlohmann::json astronomize;
+        nlohmann::json cockhorse;
+        nlohmann::json copular;
+        nlohmann::json dagomba;
+        nlohmann::json draffy;
+        nlohmann::json foreigner;
+        nlohmann::json guyandot;
+        nlohmann::json neurogliosis;
+        nlohmann::json osmious;
+        nlohmann::json palpitate;
+        nlohmann::json rebukeable;
+        nlohmann::json reinwardtia;
+        nlohmann::json reservatory;
+        nlohmann::json scalt;
+        nlohmann::json scripturalize;
+        nlohmann::json tintometer;
+        nlohmann::json tritoness;
+        nlohmann::json undergrade;
+        nlohmann::json undermountain;
+
+        public:
+        const nlohmann::json & get_apoise() const { return apoise; }
+        nlohmann::json & get_mutable_apoise() { return apoise; }
+        void set_apoise(const nlohmann::json & value) { this->apoise = value; }
+
+        const nlohmann::json & get_astronomize() const { return astronomize; }
+        nlohmann::json & get_mutable_astronomize() { return astronomize; }
+        void set_astronomize(const nlohmann::json & value) { this->astronomize = value; }
+
+        const nlohmann::json & get_cockhorse() const { return cockhorse; }
+        nlohmann::json & get_mutable_cockhorse() { return cockhorse; }
+        void set_cockhorse(const nlohmann::json & value) { this->cockhorse = value; }
+
+        const nlohmann::json & get_copular() const { return copular; }
+        nlohmann::json & get_mutable_copular() { return copular; }
+        void set_copular(const nlohmann::json & value) { this->copular = value; }
+
+        const nlohmann::json & get_dagomba() const { return dagomba; }
+        nlohmann::json & get_mutable_dagomba() { return dagomba; }
+        void set_dagomba(const nlohmann::json & value) { this->dagomba = value; }
+
+        const nlohmann::json & get_draffy() const { return draffy; }
+        nlohmann::json & get_mutable_draffy() { return draffy; }
+        void set_draffy(const nlohmann::json & value) { this->draffy = value; }
+
+        const nlohmann::json & get_foreigner() const { return foreigner; }
+        nlohmann::json & get_mutable_foreigner() { return foreigner; }
+        void set_foreigner(const nlohmann::json & value) { this->foreigner = value; }
+
+        const nlohmann::json & get_guyandot() const { return guyandot; }
+        nlohmann::json & get_mutable_guyandot() { return guyandot; }
+        void set_guyandot(const nlohmann::json & value) { this->guyandot = value; }
+
+        const nlohmann::json & get_neurogliosis() const { return neurogliosis; }
+        nlohmann::json & get_mutable_neurogliosis() { return neurogliosis; }
+        void set_neurogliosis(const nlohmann::json & value) { this->neurogliosis = value; }
+
+        const nlohmann::json & get_osmious() const { return osmious; }
+        nlohmann::json & get_mutable_osmious() { return osmious; }
+        void set_osmious(const nlohmann::json & value) { this->osmious = value; }
+
+        const nlohmann::json & get_palpitate() const { return palpitate; }
+        nlohmann::json & get_mutable_palpitate() { return palpitate; }
+        void set_palpitate(const nlohmann::json & value) { this->palpitate = value; }
+
+        const nlohmann::json & get_rebukeable() const { return rebukeable; }
+        nlohmann::json & get_mutable_rebukeable() { return rebukeable; }
+        void set_rebukeable(const nlohmann::json & value) { this->rebukeable = value; }
+
+        const nlohmann::json & get_reinwardtia() const { return reinwardtia; }
+        nlohmann::json & get_mutable_reinwardtia() { return reinwardtia; }
+        void set_reinwardtia(const nlohmann::json & value) { this->reinwardtia = value; }
+
+        const nlohmann::json & get_reservatory() const { return reservatory; }
+        nlohmann::json & get_mutable_reservatory() { return reservatory; }
+        void set_reservatory(const nlohmann::json & value) { this->reservatory = value; }
+
+        const nlohmann::json & get_scalt() const { return scalt; }
+        nlohmann::json & get_mutable_scalt() { return scalt; }
+        void set_scalt(const nlohmann::json & value) { this->scalt = value; }
+
+        const nlohmann::json & get_scripturalize() const { return scripturalize; }
+        nlohmann::json & get_mutable_scripturalize() { return scripturalize; }
+        void set_scripturalize(const nlohmann::json & value) { this->scripturalize = value; }
+
+        const nlohmann::json & get_tintometer() const { return tintometer; }
+        nlohmann::json & get_mutable_tintometer() { return tintometer; }
+        void set_tintometer(const nlohmann::json & value) { this->tintometer = value; }
+
+        const nlohmann::json & get_tritoness() const { return tritoness; }
+        nlohmann::json & get_mutable_tritoness() { return tritoness; }
+        void set_tritoness(const nlohmann::json & value) { this->tritoness = value; }
+
+        const nlohmann::json & get_undergrade() const { return undergrade; }
+        nlohmann::json & get_mutable_undergrade() { return undergrade; }
+        void set_undergrade(const nlohmann::json & value) { this->undergrade = value; }
+
+        const nlohmann::json & get_undermountain() const { return undermountain; }
+        nlohmann::json & get_mutable_undermountain() { return undermountain; }
+        void set_undermountain(const nlohmann::json & value) { this->undermountain = value; }
+    };
+
+    using FenkElement = std::variant<FenkClass, std::string>;
+
+    class FlagmakingClass {
+        public:
+        FlagmakingClass() = default;
+        virtual ~FlagmakingClass() = default;
+
+        private:
+        nlohmann::json albarco;
+        nlohmann::json bunodonta;
+        nlohmann::json hornify;
+        nlohmann::json hydrocorisae;
+        nlohmann::json hypoglossus;
+        nlohmann::json inexpiably;
+        nlohmann::json ingratitude;
+        nlohmann::json ladyfly;
+        nlohmann::json medicament;
+        nlohmann::json monogrammatic;
+        nlohmann::json nobbut;
+        nlohmann::json notacanthidae;
+        nlohmann::json polyplacophore;
+        nlohmann::json proexercise;
+        nlohmann::json protoplast;
+        nlohmann::json puzzling;
+        nlohmann::json splanchnoskeleton;
+        nlohmann::json unloveliness;
+        nlohmann::json unquarantined;
+        nlohmann::json unrenounceable;
+
+        public:
+        const nlohmann::json & get_albarco() const { return albarco; }
+        nlohmann::json & get_mutable_albarco() { return albarco; }
+        void set_albarco(const nlohmann::json & value) { this->albarco = value; }
+
+        const nlohmann::json & get_bunodonta() const { return bunodonta; }
+        nlohmann::json & get_mutable_bunodonta() { return bunodonta; }
+        void set_bunodonta(const nlohmann::json & value) { this->bunodonta = value; }
+
+        const nlohmann::json & get_hornify() const { return hornify; }
+        nlohmann::json & get_mutable_hornify() { return hornify; }
+        void set_hornify(const nlohmann::json & value) { this->hornify = value; }
+
+        const nlohmann::json & get_hydrocorisae() const { return hydrocorisae; }
+        nlohmann::json & get_mutable_hydrocorisae() { return hydrocorisae; }
+        void set_hydrocorisae(const nlohmann::json & value) { this->hydrocorisae = value; }
+
+        const nlohmann::json & get_hypoglossus() const { return hypoglossus; }
+        nlohmann::json & get_mutable_hypoglossus() { return hypoglossus; }
+        void set_hypoglossus(const nlohmann::json & value) { this->hypoglossus = value; }
+
+        const nlohmann::json & get_inexpiably() const { return inexpiably; }
+        nlohmann::json & get_mutable_inexpiably() { return inexpiably; }
+        void set_inexpiably(const nlohmann::json & value) { this->inexpiably = value; }
+
+        const nlohmann::json & get_ingratitude() const { return ingratitude; }
+        nlohmann::json & get_mutable_ingratitude() { return ingratitude; }
+        void set_ingratitude(const nlohmann::json & value) { this->ingratitude = value; }
+
+        const nlohmann::json & get_ladyfly() const { return ladyfly; }
+        nlohmann::json & get_mutable_ladyfly() { return ladyfly; }
+        void set_ladyfly(const nlohmann::json & value) { this->ladyfly = value; }
+
+        const nlohmann::json & get_medicament() const { return medicament; }
+        nlohmann::json & get_mutable_medicament() { return medicament; }
+        void set_medicament(const nlohmann::json & value) { this->medicament = value; }
+
+        const nlohmann::json & get_monogrammatic() const { return monogrammatic; }
+        nlohmann::json & get_mutable_monogrammatic() { return monogrammatic; }
+        void set_monogrammatic(const nlohmann::json & value) { this->monogrammatic = value; }
+
+        const nlohmann::json & get_nobbut() const { return nobbut; }
+        nlohmann::json & get_mutable_nobbut() { return nobbut; }
+        void set_nobbut(const nlohmann::json & value) { this->nobbut = value; }
+
+        const nlohmann::json & get_notacanthidae() const { return notacanthidae; }
+        nlohmann::json & get_mutable_notacanthidae() { return notacanthidae; }
+        void set_notacanthidae(const nlohmann::json & value) { this->notacanthidae = value; }
+
+        const nlohmann::json & get_polyplacophore() const { return polyplacophore; }
+        nlohmann::json & get_mutable_polyplacophore() { return polyplacophore; }
+        void set_polyplacophore(const nlohmann::json & value) { this->polyplacophore = value; }
+
+        const nlohmann::json & get_proexercise() const { return proexercise; }
+        nlohmann::json & get_mutable_proexercise() { return proexercise; }
+        void set_proexercise(const nlohmann::json & value) { this->proexercise = value; }
+
+        const nlohmann::json & get_protoplast() const { return protoplast; }
+        nlohmann::json & get_mutable_protoplast() { return protoplast; }
+        void set_protoplast(const nlohmann::json & value) { this->protoplast = value; }
+
+        const nlohmann::json & get_puzzling() const { return puzzling; }
+        nlohmann::json & get_mutable_puzzling() { return puzzling; }
+        void set_puzzling(const nlohmann::json & value) { this->puzzling = value; }
+
+        const nlohmann::json & get_splanchnoskeleton() const { return splanchnoskeleton; }
+        nlohmann::json & get_mutable_splanchnoskeleton() { return splanchnoskeleton; }
+        void set_splanchnoskeleton(const nlohmann::json & value) { this->splanchnoskeleton = value; }
+
+        const nlohmann::json & get_unloveliness() const { return unloveliness; }
+        nlohmann::json & get_mutable_unloveliness() { return unloveliness; }
+        void set_unloveliness(const nlohmann::json & value) { this->unloveliness = value; }
+
+        const nlohmann::json & get_unquarantined() const { return unquarantined; }
+        nlohmann::json & get_mutable_unquarantined() { return unquarantined; }
+        void set_unquarantined(const nlohmann::json & value) { this->unquarantined = value; }
+
+        const nlohmann::json & get_unrenounceable() const { return unrenounceable; }
+        nlohmann::json & get_mutable_unrenounceable() { return unrenounceable; }
+        void set_unrenounceable(const nlohmann::json & value) { this->unrenounceable = value; }
+    };
+
+    using FlagmakingElement = std::variant<bool, FlagmakingClass, double>;
+
+    using Fluorometer = std::optional<std::variant<int64_t, std::string>>;
+
+    using Fuzzy = std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>;
+
+    using Gardenward = std::variant<std::vector<int64_t>, bool, std::string>;
+
+    using Generalissimo = std::optional<std::variant<bool, std::map<std::string, int64_t>>>;
+
+    using Hemicrystalline = std::variant<CimeliaClass, std::string>;
+
+    class HemocoeleClass {
+        public:
+        HemocoeleClass() = default;
+        virtual ~HemocoeleClass() = default;
+
+        private:
+        nlohmann::json acrogamy;
+        nlohmann::json amelification;
+        nlohmann::json autobiographic;
+        nlohmann::json berat;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json disproportionably;
+        nlohmann::json erythrite;
+        nlohmann::json graphic;
+        nlohmann::json hepatological;
+        std::optional<bool> homocerc;
+        nlohmann::json incommensurably;
+        nlohmann::json misaffirm;
+        nlohmann::json nonbookish;
+        nlohmann::json pocketbook;
+        nlohmann::json sclerometric;
+        nlohmann::json stambouline;
+        nlohmann::json stickpin;
+        nlohmann::json tubulure;
+        nlohmann::json undelated;
+        nlohmann::json unsalt;
+        nlohmann::json untutelar;
+        nlohmann::json vagrant;
+        nlohmann::json walt;
+
+        public:
+        const nlohmann::json & get_acrogamy() const { return acrogamy; }
+        nlohmann::json & get_mutable_acrogamy() { return acrogamy; }
+        void set_acrogamy(const nlohmann::json & value) { this->acrogamy = value; }
+
+        const nlohmann::json & get_amelification() const { return amelification; }
+        nlohmann::json & get_mutable_amelification() { return amelification; }
+        void set_amelification(const nlohmann::json & value) { this->amelification = value; }
+
+        const nlohmann::json & get_autobiographic() const { return autobiographic; }
+        nlohmann::json & get_mutable_autobiographic() { return autobiographic; }
+        void set_autobiographic(const nlohmann::json & value) { this->autobiographic = value; }
+
+        const nlohmann::json & get_berat() const { return berat; }
+        nlohmann::json & get_mutable_berat() { return berat; }
+        void set_berat(const nlohmann::json & value) { this->berat = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_disproportionably() const { return disproportionably; }
+        nlohmann::json & get_mutable_disproportionably() { return disproportionably; }
+        void set_disproportionably(const nlohmann::json & value) { this->disproportionably = value; }
+
+        const nlohmann::json & get_erythrite() const { return erythrite; }
+        nlohmann::json & get_mutable_erythrite() { return erythrite; }
+        void set_erythrite(const nlohmann::json & value) { this->erythrite = value; }
+
+        const nlohmann::json & get_graphic() const { return graphic; }
+        nlohmann::json & get_mutable_graphic() { return graphic; }
+        void set_graphic(const nlohmann::json & value) { this->graphic = value; }
+
+        const nlohmann::json & get_hepatological() const { return hepatological; }
+        nlohmann::json & get_mutable_hepatological() { return hepatological; }
+        void set_hepatological(const nlohmann::json & value) { this->hepatological = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_incommensurably() const { return incommensurably; }
+        nlohmann::json & get_mutable_incommensurably() { return incommensurably; }
+        void set_incommensurably(const nlohmann::json & value) { this->incommensurably = value; }
+
+        const nlohmann::json & get_misaffirm() const { return misaffirm; }
+        nlohmann::json & get_mutable_misaffirm() { return misaffirm; }
+        void set_misaffirm(const nlohmann::json & value) { this->misaffirm = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_pocketbook() const { return pocketbook; }
+        nlohmann::json & get_mutable_pocketbook() { return pocketbook; }
+        void set_pocketbook(const nlohmann::json & value) { this->pocketbook = value; }
+
+        const nlohmann::json & get_sclerometric() const { return sclerometric; }
+        nlohmann::json & get_mutable_sclerometric() { return sclerometric; }
+        void set_sclerometric(const nlohmann::json & value) { this->sclerometric = value; }
+
+        const nlohmann::json & get_stambouline() const { return stambouline; }
+        nlohmann::json & get_mutable_stambouline() { return stambouline; }
+        void set_stambouline(const nlohmann::json & value) { this->stambouline = value; }
+
+        const nlohmann::json & get_stickpin() const { return stickpin; }
+        nlohmann::json & get_mutable_stickpin() { return stickpin; }
+        void set_stickpin(const nlohmann::json & value) { this->stickpin = value; }
+
+        const nlohmann::json & get_tubulure() const { return tubulure; }
+        nlohmann::json & get_mutable_tubulure() { return tubulure; }
+        void set_tubulure(const nlohmann::json & value) { this->tubulure = value; }
+
+        const nlohmann::json & get_undelated() const { return undelated; }
+        nlohmann::json & get_mutable_undelated() { return undelated; }
+        void set_undelated(const nlohmann::json & value) { this->undelated = value; }
+
+        const nlohmann::json & get_unsalt() const { return unsalt; }
+        nlohmann::json & get_mutable_unsalt() { return unsalt; }
+        void set_unsalt(const nlohmann::json & value) { this->unsalt = value; }
+
+        const nlohmann::json & get_untutelar() const { return untutelar; }
+        nlohmann::json & get_mutable_untutelar() { return untutelar; }
+        void set_untutelar(const nlohmann::json & value) { this->untutelar = value; }
+
+        const nlohmann::json & get_vagrant() const { return vagrant; }
+        nlohmann::json & get_mutable_vagrant() { return vagrant; }
+        void set_vagrant(const nlohmann::json & value) { this->vagrant = value; }
+
+        const nlohmann::json & get_walt() const { return walt; }
+        nlohmann::json & get_mutable_walt() { return walt; }
+        void set_walt(const nlohmann::json & value) { this->walt = value; }
+    };
+
+    using HemocoeleElement = std::variant<std::vector<int64_t>, HemocoeleClass>;
+
+    using Hoister = std::optional<std::variant<CimeliaClass, std::string>>;
+
+    using Hyperpiesi = std::optional<std::variant<std::vector<nlohmann::json>, CimeliaClass>>;
+
+    using Hyppish = std::optional<std::variant<bool, std::string>>;
+
+    using Idealizer = std::variant<std::vector<nlohmann::json>, CimeliaClass, int64_t>;
+
+    using Incrustator = std::variant<std::vector<int64_t>, int64_t, std::string>;
+
+    using Intentiveness = std::variant<CimeliaClass, double, std::string>;
+
+    class Interacinar {
+        public:
+        Interacinar() = default;
+        virtual ~Interacinar() = default;
+
+        private:
+        double assapan;
+        bool benefactorship;
+        std::string triseriatim;
+        int64_t tubbing;
+        nlohmann::json untrimmed;
+
+        public:
+        const double & get_assapan() const { return assapan; }
+        double & get_mutable_assapan() { return assapan; }
+        void set_assapan(const double & value) { this->assapan = value; }
+
+        const bool & get_benefactorship() const { return benefactorship; }
+        bool & get_mutable_benefactorship() { return benefactorship; }
+        void set_benefactorship(const bool & value) { this->benefactorship = value; }
+
+        const std::string & get_triseriatim() const { return triseriatim; }
+        std::string & get_mutable_triseriatim() { return triseriatim; }
+        void set_triseriatim(const std::string & value) { this->triseriatim = value; }
+
+        const int64_t & get_tubbing() const { return tubbing; }
+        int64_t & get_mutable_tubbing() { return tubbing; }
+        void set_tubbing(const int64_t & value) { this->tubbing = value; }
+
+        const nlohmann::json & get_untrimmed() const { return untrimmed; }
+        nlohmann::json & get_mutable_untrimmed() { return untrimmed; }
+        void set_untrimmed(const nlohmann::json & value) { this->untrimmed = value; }
+    };
+
+    using Jacutinga = std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::string centrodesmose;
+        std::vector<CerographElement> cerograph;
+        std::vector<ChemotherapeuticElement> chemotherapeutics;
+        std::vector<CimeliaElement> cimelia;
+        int64_t citrated;
+        std::vector<Clinodome> clinodome;
+        std::vector<CoadjustElement> coadjust;
+        std::vector<Consilience> consilience;
+        std::vector<Constructor> constructor;
+        std::vector<Continuative> continuative;
+        std::vector<CredulityElement> credulity;
+        std::vector<Creviced> creviced;
+        std::vector<std::vector<std::optional<int64_t>>> cubiculum;
+        std::vector<DeruralizeElement> deruralize;
+        std::vector<DiaereseElement> diaereses;
+        std::vector<std::optional<std::vector<nlohmann::json>>> dissolution;
+        std::vector<Downstroke> downstroke;
+        std::vector<std::optional<double>> electrotautomerism;
+        std::vector<Eleutheromania> eleutheromania;
+        Encrust encrust;
+        std::vector<Entomoid> entomoid;
+        std::vector<Epipaleolithic> epipaleolithic;
+        std::vector<Expropriable> expropriable;
+        std::vector<FagginglyElement> faggingly;
+        std::vector<FenkElement> fenks;
+        std::vector<FlagmakingElement> flagmaking;
+        std::vector<Fluorometer> fluorometer;
+        std::vector<std::optional<int64_t>> fulsome;
+        std::vector<Fuzzy> fuzzy;
+        std::vector<Gardenward> gardenwards;
+        std::vector<Generalissimo> generalissimo;
+        std::vector<std::optional<std::map<std::string, int64_t>>> habeas;
+        std::vector<Hemicrystalline> hemicrystalline;
+        std::vector<HemocoeleElement> hemocoele;
+        std::vector<Hoister> hoister;
+        std::vector<Hyperpiesi> hyperpiesis;
+        std::vector<Hyppish> hyppish;
+        std::vector<Idealizer> idealizer;
+        std::vector<Incrustator> incrustator;
+        std::vector<Intentiveness> intentiveness;
+        Interacinar interacinar;
+        std::vector<std::optional<std::vector<int64_t>>> intercorrelation;
+        std::vector<Jacutinga> jacutinga;
+
+        public:
+        const std::string & get_centrodesmose() const { return centrodesmose; }
+        std::string & get_mutable_centrodesmose() { return centrodesmose; }
+        void set_centrodesmose(const std::string & value) { this->centrodesmose = value; }
+
+        const std::vector<CerographElement> & get_cerograph() const { return cerograph; }
+        std::vector<CerographElement> & get_mutable_cerograph() { return cerograph; }
+        void set_cerograph(const std::vector<CerographElement> & value) { this->cerograph = value; }
+
+        const std::vector<ChemotherapeuticElement> & get_chemotherapeutics() const { return chemotherapeutics; }
+        std::vector<ChemotherapeuticElement> & get_mutable_chemotherapeutics() { return chemotherapeutics; }
+        void set_chemotherapeutics(const std::vector<ChemotherapeuticElement> & value) { this->chemotherapeutics = value; }
+
+        const std::vector<CimeliaElement> & get_cimelia() const { return cimelia; }
+        std::vector<CimeliaElement> & get_mutable_cimelia() { return cimelia; }
+        void set_cimelia(const std::vector<CimeliaElement> & value) { this->cimelia = value; }
+
+        const int64_t & get_citrated() const { return citrated; }
+        int64_t & get_mutable_citrated() { return citrated; }
+        void set_citrated(const int64_t & value) { this->citrated = value; }
+
+        const std::vector<Clinodome> & get_clinodome() const { return clinodome; }
+        std::vector<Clinodome> & get_mutable_clinodome() { return clinodome; }
+        void set_clinodome(const std::vector<Clinodome> & value) { this->clinodome = value; }
+
+        const std::vector<CoadjustElement> & get_coadjust() const { return coadjust; }
+        std::vector<CoadjustElement> & get_mutable_coadjust() { return coadjust; }
+        void set_coadjust(const std::vector<CoadjustElement> & value) { this->coadjust = value; }
+
+        const std::vector<Consilience> & get_consilience() const { return consilience; }
+        std::vector<Consilience> & get_mutable_consilience() { return consilience; }
+        void set_consilience(const std::vector<Consilience> & value) { this->consilience = value; }
+
+        const std::vector<Constructor> & get_constructor() const { return constructor; }
+        std::vector<Constructor> & get_mutable_constructor() { return constructor; }
+        void set_constructor(const std::vector<Constructor> & value) { this->constructor = value; }
+
+        const std::vector<Continuative> & get_continuative() const { return continuative; }
+        std::vector<Continuative> & get_mutable_continuative() { return continuative; }
+        void set_continuative(const std::vector<Continuative> & value) { this->continuative = value; }
+
+        const std::vector<CredulityElement> & get_credulity() const { return credulity; }
+        std::vector<CredulityElement> & get_mutable_credulity() { return credulity; }
+        void set_credulity(const std::vector<CredulityElement> & value) { this->credulity = value; }
+
+        const std::vector<Creviced> & get_creviced() const { return creviced; }
+        std::vector<Creviced> & get_mutable_creviced() { return creviced; }
+        void set_creviced(const std::vector<Creviced> & value) { this->creviced = value; }
+
+        const std::vector<std::vector<std::optional<int64_t>>> & get_cubiculum() const { return cubiculum; }
+        std::vector<std::vector<std::optional<int64_t>>> & get_mutable_cubiculum() { return cubiculum; }
+        void set_cubiculum(const std::vector<std::vector<std::optional<int64_t>>> & value) { this->cubiculum = value; }
+
+        const std::vector<DeruralizeElement> & get_deruralize() const { return deruralize; }
+        std::vector<DeruralizeElement> & get_mutable_deruralize() { return deruralize; }
+        void set_deruralize(const std::vector<DeruralizeElement> & value) { this->deruralize = value; }
+
+        const std::vector<DiaereseElement> & get_diaereses() const { return diaereses; }
+        std::vector<DiaereseElement> & get_mutable_diaereses() { return diaereses; }
+        void set_diaereses(const std::vector<DiaereseElement> & value) { this->diaereses = value; }
+
+        const std::vector<std::optional<std::vector<nlohmann::json>>> & get_dissolution() const { return dissolution; }
+        std::vector<std::optional<std::vector<nlohmann::json>>> & get_mutable_dissolution() { return dissolution; }
+        void set_dissolution(const std::vector<std::optional<std::vector<nlohmann::json>>> & value) { this->dissolution = value; }
+
+        const std::vector<Downstroke> & get_downstroke() const { return downstroke; }
+        std::vector<Downstroke> & get_mutable_downstroke() { return downstroke; }
+        void set_downstroke(const std::vector<Downstroke> & value) { this->downstroke = value; }
+
+        const std::vector<std::optional<double>> & get_electrotautomerism() const { return electrotautomerism; }
+        std::vector<std::optional<double>> & get_mutable_electrotautomerism() { return electrotautomerism; }
+        void set_electrotautomerism(const std::vector<std::optional<double>> & value) { this->electrotautomerism = value; }
+
+        const std::vector<Eleutheromania> & get_eleutheromania() const { return eleutheromania; }
+        std::vector<Eleutheromania> & get_mutable_eleutheromania() { return eleutheromania; }
+        void set_eleutheromania(const std::vector<Eleutheromania> & value) { this->eleutheromania = value; }
+
+        const Encrust & get_encrust() const { return encrust; }
+        Encrust & get_mutable_encrust() { return encrust; }
+        void set_encrust(const Encrust & value) { this->encrust = value; }
+
+        const std::vector<Entomoid> & get_entomoid() const { return entomoid; }
+        std::vector<Entomoid> & get_mutable_entomoid() { return entomoid; }
+        void set_entomoid(const std::vector<Entomoid> & value) { this->entomoid = value; }
+
+        const std::vector<Epipaleolithic> & get_epipaleolithic() const { return epipaleolithic; }
+        std::vector<Epipaleolithic> & get_mutable_epipaleolithic() { return epipaleolithic; }
+        void set_epipaleolithic(const std::vector<Epipaleolithic> & value) { this->epipaleolithic = value; }
+
+        const std::vector<Expropriable> & get_expropriable() const { return expropriable; }
+        std::vector<Expropriable> & get_mutable_expropriable() { return expropriable; }
+        void set_expropriable(const std::vector<Expropriable> & value) { this->expropriable = value; }
+
+        const std::vector<FagginglyElement> & get_faggingly() const { return faggingly; }
+        std::vector<FagginglyElement> & get_mutable_faggingly() { return faggingly; }
+        void set_faggingly(const std::vector<FagginglyElement> & value) { this->faggingly = value; }
+
+        const std::vector<FenkElement> & get_fenks() const { return fenks; }
+        std::vector<FenkElement> & get_mutable_fenks() { return fenks; }
+        void set_fenks(const std::vector<FenkElement> & value) { this->fenks = value; }
+
+        const std::vector<FlagmakingElement> & get_flagmaking() const { return flagmaking; }
+        std::vector<FlagmakingElement> & get_mutable_flagmaking() { return flagmaking; }
+        void set_flagmaking(const std::vector<FlagmakingElement> & value) { this->flagmaking = value; }
+
+        const std::vector<Fluorometer> & get_fluorometer() const { return fluorometer; }
+        std::vector<Fluorometer> & get_mutable_fluorometer() { return fluorometer; }
+        void set_fluorometer(const std::vector<Fluorometer> & value) { this->fluorometer = value; }
+
+        const std::vector<std::optional<int64_t>> & get_fulsome() const { return fulsome; }
+        std::vector<std::optional<int64_t>> & get_mutable_fulsome() { return fulsome; }
+        void set_fulsome(const std::vector<std::optional<int64_t>> & value) { this->fulsome = value; }
+
+        const std::vector<Fuzzy> & get_fuzzy() const { return fuzzy; }
+        std::vector<Fuzzy> & get_mutable_fuzzy() { return fuzzy; }
+        void set_fuzzy(const std::vector<Fuzzy> & value) { this->fuzzy = value; }
+
+        const std::vector<Gardenward> & get_gardenwards() const { return gardenwards; }
+        std::vector<Gardenward> & get_mutable_gardenwards() { return gardenwards; }
+        void set_gardenwards(const std::vector<Gardenward> & value) { this->gardenwards = value; }
+
+        const std::vector<Generalissimo> & get_generalissimo() const { return generalissimo; }
+        std::vector<Generalissimo> & get_mutable_generalissimo() { return generalissimo; }
+        void set_generalissimo(const std::vector<Generalissimo> & value) { this->generalissimo = value; }
+
+        const std::vector<std::optional<std::map<std::string, int64_t>>> & get_habeas() const { return habeas; }
+        std::vector<std::optional<std::map<std::string, int64_t>>> & get_mutable_habeas() { return habeas; }
+        void set_habeas(const std::vector<std::optional<std::map<std::string, int64_t>>> & value) { this->habeas = value; }
+
+        const std::vector<Hemicrystalline> & get_hemicrystalline() const { return hemicrystalline; }
+        std::vector<Hemicrystalline> & get_mutable_hemicrystalline() { return hemicrystalline; }
+        void set_hemicrystalline(const std::vector<Hemicrystalline> & value) { this->hemicrystalline = value; }
+
+        const std::vector<HemocoeleElement> & get_hemocoele() const { return hemocoele; }
+        std::vector<HemocoeleElement> & get_mutable_hemocoele() { return hemocoele; }
+        void set_hemocoele(const std::vector<HemocoeleElement> & value) { this->hemocoele = value; }
+
+        const std::vector<Hoister> & get_hoister() const { return hoister; }
+        std::vector<Hoister> & get_mutable_hoister() { return hoister; }
+        void set_hoister(const std::vector<Hoister> & value) { this->hoister = value; }
+
+        const std::vector<Hyperpiesi> & get_hyperpiesis() const { return hyperpiesis; }
+        std::vector<Hyperpiesi> & get_mutable_hyperpiesis() { return hyperpiesis; }
+        void set_hyperpiesis(const std::vector<Hyperpiesi> & value) { this->hyperpiesis = value; }
+
+        const std::vector<Hyppish> & get_hyppish() const { return hyppish; }
+        std::vector<Hyppish> & get_mutable_hyppish() { return hyppish; }
+        void set_hyppish(const std::vector<Hyppish> & value) { this->hyppish = value; }
+
+        const std::vector<Idealizer> & get_idealizer() const { return idealizer; }
+        std::vector<Idealizer> & get_mutable_idealizer() { return idealizer; }
+        void set_idealizer(const std::vector<Idealizer> & value) { this->idealizer = value; }
+
+        const std::vector<Incrustator> & get_incrustator() const { return incrustator; }
+        std::vector<Incrustator> & get_mutable_incrustator() { return incrustator; }
+        void set_incrustator(const std::vector<Incrustator> & value) { this->incrustator = value; }
+
+        const std::vector<Intentiveness> & get_intentiveness() const { return intentiveness; }
+        std::vector<Intentiveness> & get_mutable_intentiveness() { return intentiveness; }
+        void set_intentiveness(const std::vector<Intentiveness> & value) { this->intentiveness = value; }
+
+        const Interacinar & get_interacinar() const { return interacinar; }
+        Interacinar & get_mutable_interacinar() { return interacinar; }
+        void set_interacinar(const Interacinar & value) { this->interacinar = value; }
+
+        const std::vector<std::optional<std::vector<int64_t>>> & get_intercorrelation() const { return intercorrelation; }
+        std::vector<std::optional<std::vector<int64_t>>> & get_mutable_intercorrelation() { return intercorrelation; }
+        void set_intercorrelation(const std::vector<std::optional<std::vector<int64_t>>> & value) { this->intercorrelation = value; }
+
+        const std::vector<Jacutinga> & get_jacutinga() const { return jacutinga; }
+        std::vector<Jacutinga> & get_mutable_jacutinga() { return jacutinga; }
+        void set_jacutinga(const std::vector<Jacutinga> & value) { this->jacutinga = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, CerographClass & x);
+void to_json(json & j, const CerographClass & x);
+
+void from_json(const json & j, ChemotherapeuticClass & x);
+void to_json(json & j, const ChemotherapeuticClass & x);
+
+void from_json(const json & j, CimeliaClass & x);
+void to_json(json & j, const CimeliaClass & x);
+
+void from_json(const json & j, CoadjustClass & x);
+void to_json(json & j, const CoadjustClass & x);
+
+void from_json(const json & j, CredulityClass & x);
+void to_json(json & j, const CredulityClass & x);
+
+void from_json(const json & j, DeruralizeClass & x);
+void to_json(json & j, const DeruralizeClass & x);
+
+void from_json(const json & j, DiaereseClass & x);
+void to_json(json & j, const DiaereseClass & x);
+
+void from_json(const json & j, Encrust & x);
+void to_json(json & j, const Encrust & x);
+
+void from_json(const json & j, FagginglyClass & x);
+void to_json(json & j, const FagginglyClass & x);
+
+void from_json(const json & j, FenkClass & x);
+void to_json(json & j, const FenkClass & x);
+
+void from_json(const json & j, FlagmakingClass & x);
+void to_json(json & j, const FlagmakingClass & x);
+
+void from_json(const json & j, HemocoeleClass & x);
+void to_json(json & j, const HemocoeleClass & x);
+
+void from_json(const json & j, Interacinar & x);
+void to_json(json & j, const Interacinar & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<quicktype::CerographClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CerographClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CerographClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::ChemotherapeuticClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CoadjustClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::CoadjustClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::CoadjustClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CredulityClass, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CredulityClass, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::CimeliaClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::CimeliaClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FagginglyClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::FagginglyClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::FagginglyClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FenkClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::FenkClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::FenkClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::FlagmakingClass, double> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::FlagmakingClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CimeliaClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CimeliaClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::string>> {
+    static void from_json(const json & j, std::variant<bool, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::CimeliaClass, double, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::CimeliaClass, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, CerographClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apotropaion(get_untyped(j, "apotropaion"));
+        x.set_casuary(get_untyped(j, "casuary"));
+        x.set_creaker(get_untyped(j, "creaker"));
+        x.set_disqualification(get_untyped(j, "disqualification"));
+        x.set_imperatorious(get_untyped(j, "imperatorious"));
+        x.set_impermeabilize(get_untyped(j, "impermeabilize"));
+        x.set_metastoma(get_untyped(j, "metastoma"));
+        x.set_noctidiurnal(get_untyped(j, "noctidiurnal"));
+        x.set_nonreserve(get_untyped(j, "nonreserve"));
+        x.set_ophthalmotonometry(get_untyped(j, "ophthalmotonometry"));
+        x.set_pailful(get_untyped(j, "pailful"));
+        x.set_pigfish(get_untyped(j, "pigfish"));
+        x.set_pongee(get_untyped(j, "pongee"));
+        x.set_prosodical(get_untyped(j, "prosodical"));
+        x.set_scrofuloderm(get_untyped(j, "scrofuloderm"));
+        x.set_storekeeping(get_untyped(j, "storekeeping"));
+        x.set_therologist(get_untyped(j, "therologist"));
+        x.set_tolowa(get_untyped(j, "Tolowa"));
+        x.set_tradeful(get_untyped(j, "tradeful"));
+        x.set_unriveting(get_untyped(j, "unriveting"));
+    }
+
+    inline void to_json(json & j, const CerographClass & x) {
+        j = json::object();
+        j["apotropaion"] = x.get_apotropaion();
+        j["casuary"] = x.get_casuary();
+        j["creaker"] = x.get_creaker();
+        j["disqualification"] = x.get_disqualification();
+        j["imperatorious"] = x.get_imperatorious();
+        j["impermeabilize"] = x.get_impermeabilize();
+        j["metastoma"] = x.get_metastoma();
+        j["noctidiurnal"] = x.get_noctidiurnal();
+        j["nonreserve"] = x.get_nonreserve();
+        j["ophthalmotonometry"] = x.get_ophthalmotonometry();
+        j["pailful"] = x.get_pailful();
+        j["pigfish"] = x.get_pigfish();
+        j["pongee"] = x.get_pongee();
+        j["prosodical"] = x.get_prosodical();
+        j["scrofuloderm"] = x.get_scrofuloderm();
+        j["storekeeping"] = x.get_storekeeping();
+        j["therologist"] = x.get_therologist();
+        j["Tolowa"] = x.get_tolowa();
+        j["tradeful"] = x.get_tradeful();
+        j["unriveting"] = x.get_unriveting();
+    }
+
+    inline void from_json(const json & j, ChemotherapeuticClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_angioneurotic(get_untyped(j, "angioneurotic"));
+        x.set_availment(get_untyped(j, "availment"));
+        x.set_bladelet(get_untyped(j, "bladelet"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_caulis(get_untyped(j, "caulis"));
+        x.set_chalcus(get_untyped(j, "chalcus"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_enteradenological(get_untyped(j, "enteradenological"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_imporosity(get_untyped(j, "imporosity"));
+        x.set_insistently(get_untyped(j, "insistently"));
+        x.set_intraparietal(get_untyped(j, "intraparietal"));
+        x.set_ivied(get_untyped(j, "ivied"));
+        x.set_maureen(get_untyped(j, "Maureen"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_nostochine(get_untyped(j, "nostochine"));
+        x.set_nutcracker(get_untyped(j, "nutcracker"));
+        x.set_ofttimes(get_untyped(j, "ofttimes"));
+        x.set_phenocryst(get_untyped(j, "phenocryst"));
+        x.set_precoincident(get_untyped(j, "precoincident"));
+        x.set_ramiferous(get_untyped(j, "ramiferous"));
+        x.set_stagmometer(get_untyped(j, "stagmometer"));
+        x.set_tetherball(get_untyped(j, "tetherball"));
+        x.set_unshy(get_untyped(j, "unshy"));
+    }
+
+    inline void to_json(json & j, const ChemotherapeuticClass & x) {
+        j = json::object();
+        j["angioneurotic"] = x.get_angioneurotic();
+        j["availment"] = x.get_availment();
+        j["bladelet"] = x.get_bladelet();
+        j["catharticalness"] = x.get_catharticalness();
+        j["caulis"] = x.get_caulis();
+        j["chalcus"] = x.get_chalcus();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["enteradenological"] = x.get_enteradenological();
+        j["homocerc"] = x.get_homocerc();
+        j["imporosity"] = x.get_imporosity();
+        j["insistently"] = x.get_insistently();
+        j["intraparietal"] = x.get_intraparietal();
+        j["ivied"] = x.get_ivied();
+        j["Maureen"] = x.get_maureen();
+        j["nonbookish"] = x.get_nonbookish();
+        j["nostochine"] = x.get_nostochine();
+        j["nutcracker"] = x.get_nutcracker();
+        j["ofttimes"] = x.get_ofttimes();
+        j["phenocryst"] = x.get_phenocryst();
+        j["precoincident"] = x.get_precoincident();
+        j["ramiferous"] = x.get_ramiferous();
+        j["stagmometer"] = x.get_stagmometer();
+        j["tetherball"] = x.get_tetherball();
+        j["unshy"] = x.get_unshy();
+    }
+
+    inline void from_json(const json & j, CimeliaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, const CimeliaClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(const json & j, CoadjustClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amidosulphonal(get_untyped(j, "amidosulphonal"));
+        x.set_benny(get_untyped(j, "Benny"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ensnare(get_untyped(j, "ensnare"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_hybridizer(get_untyped(j, "hybridizer"));
+        x.set_leastwise(get_untyped(j, "leastwise"));
+        x.set_lof(get_untyped(j, "lof"));
+        x.set_monkhood(get_untyped(j, "monkhood"));
+        x.set_netherlandish(get_untyped(j, "Netherlandish"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_peonism(get_untyped(j, "peonism"));
+        x.set_phonelescope(get_untyped(j, "Phonelescope"));
+        x.set_porphyrogeniture(get_untyped(j, "porphyrogeniture"));
+        x.set_preindemnify(get_untyped(j, "preindemnify"));
+        x.set_rosal(get_untyped(j, "rosal"));
+        x.set_scalenous(get_untyped(j, "scalenous"));
+        x.set_scopine(get_untyped(j, "scopine"));
+        x.set_sedaceae(get_untyped(j, "Sedaceae"));
+        x.set_suberinize(get_untyped(j, "suberinize"));
+        x.set_symbiot(get_untyped(j, "symbiot"));
+        x.set_tablefellow(get_untyped(j, "tablefellow"));
+        x.set_unchargeable(get_untyped(j, "unchargeable"));
+    }
+
+    inline void to_json(json & j, const CoadjustClass & x) {
+        j = json::object();
+        j["amidosulphonal"] = x.get_amidosulphonal();
+        j["Benny"] = x.get_benny();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ensnare"] = x.get_ensnare();
+        j["homocerc"] = x.get_homocerc();
+        j["hybridizer"] = x.get_hybridizer();
+        j["leastwise"] = x.get_leastwise();
+        j["lof"] = x.get_lof();
+        j["monkhood"] = x.get_monkhood();
+        j["Netherlandish"] = x.get_netherlandish();
+        j["nonbookish"] = x.get_nonbookish();
+        j["peonism"] = x.get_peonism();
+        j["Phonelescope"] = x.get_phonelescope();
+        j["porphyrogeniture"] = x.get_porphyrogeniture();
+        j["preindemnify"] = x.get_preindemnify();
+        j["rosal"] = x.get_rosal();
+        j["scalenous"] = x.get_scalenous();
+        j["scopine"] = x.get_scopine();
+        j["Sedaceae"] = x.get_sedaceae();
+        j["suberinize"] = x.get_suberinize();
+        j["symbiot"] = x.get_symbiot();
+        j["tablefellow"] = x.get_tablefellow();
+        j["unchargeable"] = x.get_unchargeable();
+    }
+
+    inline void from_json(const json & j, CredulityClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_ammonolytic(get_untyped(j, "ammonolytic"));
+        x.set_bushmaster(get_untyped(j, "bushmaster"));
+        x.set_considering(get_untyped(j, "considering"));
+        x.set_consuetudinary(get_untyped(j, "consuetudinary"));
+        x.set_embarras(get_untyped(j, "embarras"));
+        x.set_fineness(get_untyped(j, "fineness"));
+        x.set_flaithship(get_untyped(j, "flaithship"));
+        x.set_flavia(get_untyped(j, "Flavia"));
+        x.set_gruffly(get_untyped(j, "gruffly"));
+        x.set_hedychium(get_untyped(j, "Hedychium"));
+        x.set_leadwort(get_untyped(j, "leadwort"));
+        x.set_overseriously(get_untyped(j, "overseriously"));
+        x.set_parabola(get_untyped(j, "parabola"));
+        x.set_pectinatodenticulate(get_untyped(j, "pectinatodenticulate"));
+        x.set_popean(get_untyped(j, "Popean"));
+        x.set_pornocrat(get_untyped(j, "pornocrat"));
+        x.set_quadrisect(get_untyped(j, "quadrisect"));
+        x.set_seriality(get_untyped(j, "seriality"));
+        x.set_vamphorn(get_untyped(j, "vamphorn"));
+        x.set_wharp(get_untyped(j, "wharp"));
+    }
+
+    inline void to_json(json & j, const CredulityClass & x) {
+        j = json::object();
+        j["ammonolytic"] = x.get_ammonolytic();
+        j["bushmaster"] = x.get_bushmaster();
+        j["considering"] = x.get_considering();
+        j["consuetudinary"] = x.get_consuetudinary();
+        j["embarras"] = x.get_embarras();
+        j["fineness"] = x.get_fineness();
+        j["flaithship"] = x.get_flaithship();
+        j["Flavia"] = x.get_flavia();
+        j["gruffly"] = x.get_gruffly();
+        j["Hedychium"] = x.get_hedychium();
+        j["leadwort"] = x.get_leadwort();
+        j["overseriously"] = x.get_overseriously();
+        j["parabola"] = x.get_parabola();
+        j["pectinatodenticulate"] = x.get_pectinatodenticulate();
+        j["Popean"] = x.get_popean();
+        j["pornocrat"] = x.get_pornocrat();
+        j["quadrisect"] = x.get_quadrisect();
+        j["seriality"] = x.get_seriality();
+        j["vamphorn"] = x.get_vamphorn();
+        j["wharp"] = x.get_wharp();
+    }
+
+    inline void from_json(const json & j, DeruralizeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_bockerel(get_untyped(j, "bockerel"));
+        x.set_boulder(get_untyped(j, "boulder"));
+        x.set_churrus(get_untyped(j, "churrus"));
+        x.set_counterdigged(get_untyped(j, "counterdigged"));
+        x.set_dialogite(get_untyped(j, "dialogite"));
+        x.set_digenic(get_untyped(j, "digenic"));
+        x.set_dunbird(get_untyped(j, "dunbird"));
+        x.set_ergatogyne(get_untyped(j, "ergatogyne"));
+        x.set_fiendful(get_untyped(j, "fiendful"));
+        x.set_jackrod(get_untyped(j, "jackrod"));
+        x.set_jehovistic(get_untyped(j, "Jehovistic"));
+        x.set_paninean(get_untyped(j, "Paninean"));
+        x.set_panther(get_untyped(j, "panther"));
+        x.set_placentigerous(get_untyped(j, "placentigerous"));
+        x.set_romney(get_untyped(j, "Romney"));
+        x.set_sparm(get_untyped(j, "sparm"));
+        x.set_tocsin(get_untyped(j, "tocsin"));
+        x.set_unnicked(get_untyped(j, "unnicked"));
+        x.set_unstavable(get_untyped(j, "unstavable"));
+        x.set_windfirm(get_untyped(j, "windfirm"));
+    }
+
+    inline void to_json(json & j, const DeruralizeClass & x) {
+        j = json::object();
+        j["bockerel"] = x.get_bockerel();
+        j["boulder"] = x.get_boulder();
+        j["churrus"] = x.get_churrus();
+        j["counterdigged"] = x.get_counterdigged();
+        j["dialogite"] = x.get_dialogite();
+        j["digenic"] = x.get_digenic();
+        j["dunbird"] = x.get_dunbird();
+        j["ergatogyne"] = x.get_ergatogyne();
+        j["fiendful"] = x.get_fiendful();
+        j["jackrod"] = x.get_jackrod();
+        j["Jehovistic"] = x.get_jehovistic();
+        j["Paninean"] = x.get_paninean();
+        j["panther"] = x.get_panther();
+        j["placentigerous"] = x.get_placentigerous();
+        j["Romney"] = x.get_romney();
+        j["sparm"] = x.get_sparm();
+        j["tocsin"] = x.get_tocsin();
+        j["unnicked"] = x.get_unnicked();
+        j["unstavable"] = x.get_unstavable();
+        j["windfirm"] = x.get_windfirm();
+    }
+
+    inline void from_json(const json & j, DiaereseClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amoreuxia(get_untyped(j, "Amoreuxia"));
+        x.set_ani(get_untyped(j, "ani"));
+        x.set_bernicle(get_untyped(j, "bernicle"));
+        x.set_blackwasher(get_untyped(j, "blackwasher"));
+        x.set_blowhard(get_untyped(j, "blowhard"));
+        x.set_broma(get_untyped(j, "broma"));
+        x.set_closecross(get_untyped(j, "closecross"));
+        x.set_congregationalism(get_untyped(j, "congregationalism"));
+        x.set_grayly(get_untyped(j, "grayly"));
+        x.set_historically(get_untyped(j, "historically"));
+        x.set_hoast(get_untyped(j, "hoast"));
+        x.set_irretentive(get_untyped(j, "irretentive"));
+        x.set_parcener(get_untyped(j, "parcener"));
+        x.set_pedder(get_untyped(j, "pedder"));
+        x.set_pseudoanatomic(get_untyped(j, "pseudoanatomic"));
+        x.set_rhizocarpian(get_untyped(j, "rhizocarpian"));
+        x.set_samel(get_untyped(j, "samel"));
+        x.set_silker(get_untyped(j, "silker"));
+        x.set_subdentated(get_untyped(j, "subdentated"));
+        x.set_subobscure(get_untyped(j, "subobscure"));
+    }
+
+    inline void to_json(json & j, const DiaereseClass & x) {
+        j = json::object();
+        j["Amoreuxia"] = x.get_amoreuxia();
+        j["ani"] = x.get_ani();
+        j["bernicle"] = x.get_bernicle();
+        j["blackwasher"] = x.get_blackwasher();
+        j["blowhard"] = x.get_blowhard();
+        j["broma"] = x.get_broma();
+        j["closecross"] = x.get_closecross();
+        j["congregationalism"] = x.get_congregationalism();
+        j["grayly"] = x.get_grayly();
+        j["historically"] = x.get_historically();
+        j["hoast"] = x.get_hoast();
+        j["irretentive"] = x.get_irretentive();
+        j["parcener"] = x.get_parcener();
+        j["pedder"] = x.get_pedder();
+        j["pseudoanatomic"] = x.get_pseudoanatomic();
+        j["rhizocarpian"] = x.get_rhizocarpian();
+        j["samel"] = x.get_samel();
+        j["silker"] = x.get_silker();
+        j["subdentated"] = x.get_subdentated();
+        j["subobscure"] = x.get_subobscure();
+    }
+
+    inline void from_json(const json & j, Encrust& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_comradely(get_untyped(j, "comradely"));
+        x.set_diacanthous(get_untyped(j, "diacanthous"));
+        x.set_feminineness(get_untyped(j, "feminineness"));
+        x.set_gossamered(get_untyped(j, "gossamered"));
+        x.set_hibernia(get_untyped(j, "Hibernia"));
+        x.set_hibiscus(get_untyped(j, "Hibiscus"));
+        x.set_lepidosauria(get_untyped(j, "Lepidosauria"));
+        x.set_lollingly(get_untyped(j, "lollingly"));
+        x.set_manager(get_untyped(j, "manager"));
+        x.set_mechanic(get_untyped(j, "mechanic"));
+        x.set_overminuteness(get_untyped(j, "overminuteness"));
+        x.set_papelonne(get_untyped(j, "papelonne"));
+        x.set_plebification(get_untyped(j, "plebification"));
+        x.set_pugmiller(get_untyped(j, "pugmiller"));
+        x.set_recoveror(get_untyped(j, "recoveror"));
+        x.set_spermatoblastic(get_untyped(j, "spermatoblastic"));
+        x.set_syllidae(get_untyped(j, "Syllidae"));
+        x.set_ungyved(get_untyped(j, "ungyved"));
+        x.set_whirlabout(get_untyped(j, "whirlabout"));
+        x.set_woodenware(get_untyped(j, "woodenware"));
+    }
+
+    inline void to_json(json & j, const Encrust & x) {
+        j = json::object();
+        j["comradely"] = x.get_comradely();
+        j["diacanthous"] = x.get_diacanthous();
+        j["feminineness"] = x.get_feminineness();
+        j["gossamered"] = x.get_gossamered();
+        j["Hibernia"] = x.get_hibernia();
+        j["Hibiscus"] = x.get_hibiscus();
+        j["Lepidosauria"] = x.get_lepidosauria();
+        j["lollingly"] = x.get_lollingly();
+        j["manager"] = x.get_manager();
+        j["mechanic"] = x.get_mechanic();
+        j["overminuteness"] = x.get_overminuteness();
+        j["papelonne"] = x.get_papelonne();
+        j["plebification"] = x.get_plebification();
+        j["pugmiller"] = x.get_pugmiller();
+        j["recoveror"] = x.get_recoveror();
+        j["spermatoblastic"] = x.get_spermatoblastic();
+        j["Syllidae"] = x.get_syllidae();
+        j["ungyved"] = x.get_ungyved();
+        j["whirlabout"] = x.get_whirlabout();
+        j["woodenware"] = x.get_woodenware();
+    }
+
+    inline void from_json(const json & j, FagginglyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_abranchian(get_untyped(j, "abranchian"));
+        x.set_aculeiform(get_untyped(j, "aculeiform"));
+        x.set_adiaphoristic(get_untyped(j, "adiaphoristic"));
+        x.set_adoptionism(get_untyped(j, "adoptionism"));
+        x.set_anglic(get_untyped(j, "Anglic"));
+        x.set_antrotomy(get_untyped(j, "antrotomy"));
+        x.set_coerciveness(get_untyped(j, "coerciveness"));
+        x.set_decorist(get_untyped(j, "decorist"));
+        x.set_duckhood(get_untyped(j, "duckhood"));
+        x.set_heteromeri(get_untyped(j, "Heteromeri"));
+        x.set_hypochnose(get_untyped(j, "hypochnose"));
+        x.set_lochage(get_untyped(j, "lochage"));
+        x.set_melee(get_untyped(j, "melee"));
+        x.set_nonconformitant(get_untyped(j, "nonconformitant"));
+        x.set_poinsettia(get_untyped(j, "Poinsettia"));
+        x.set_putatively(get_untyped(j, "putatively"));
+        x.set_semivolatile(get_untyped(j, "semivolatile"));
+        x.set_soleas(get_untyped(j, "soleas"));
+        x.set_unfastenable(get_untyped(j, "unfastenable"));
+        x.set_unmillinered(get_untyped(j, "unmillinered"));
+    }
+
+    inline void to_json(json & j, const FagginglyClass & x) {
+        j = json::object();
+        j["abranchian"] = x.get_abranchian();
+        j["aculeiform"] = x.get_aculeiform();
+        j["adiaphoristic"] = x.get_adiaphoristic();
+        j["adoptionism"] = x.get_adoptionism();
+        j["Anglic"] = x.get_anglic();
+        j["antrotomy"] = x.get_antrotomy();
+        j["coerciveness"] = x.get_coerciveness();
+        j["decorist"] = x.get_decorist();
+        j["duckhood"] = x.get_duckhood();
+        j["Heteromeri"] = x.get_heteromeri();
+        j["hypochnose"] = x.get_hypochnose();
+        j["lochage"] = x.get_lochage();
+        j["melee"] = x.get_melee();
+        j["nonconformitant"] = x.get_nonconformitant();
+        j["Poinsettia"] = x.get_poinsettia();
+        j["putatively"] = x.get_putatively();
+        j["semivolatile"] = x.get_semivolatile();
+        j["soleas"] = x.get_soleas();
+        j["unfastenable"] = x.get_unfastenable();
+        j["unmillinered"] = x.get_unmillinered();
+    }
+
+    inline void from_json(const json & j, FenkClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apoise(get_untyped(j, "apoise"));
+        x.set_astronomize(get_untyped(j, "astronomize"));
+        x.set_cockhorse(get_untyped(j, "cockhorse"));
+        x.set_copular(get_untyped(j, "copular"));
+        x.set_dagomba(get_untyped(j, "Dagomba"));
+        x.set_draffy(get_untyped(j, "draffy"));
+        x.set_foreigner(get_untyped(j, "foreigner"));
+        x.set_guyandot(get_untyped(j, "Guyandot"));
+        x.set_neurogliosis(get_untyped(j, "neurogliosis"));
+        x.set_osmious(get_untyped(j, "osmious"));
+        x.set_palpitate(get_untyped(j, "palpitate"));
+        x.set_rebukeable(get_untyped(j, "rebukeable"));
+        x.set_reinwardtia(get_untyped(j, "Reinwardtia"));
+        x.set_reservatory(get_untyped(j, "reservatory"));
+        x.set_scalt(get_untyped(j, "scalt"));
+        x.set_scripturalize(get_untyped(j, "scripturalize"));
+        x.set_tintometer(get_untyped(j, "tintometer"));
+        x.set_tritoness(get_untyped(j, "Tritoness"));
+        x.set_undergrade(get_untyped(j, "undergrade"));
+        x.set_undermountain(get_untyped(j, "undermountain"));
+    }
+
+    inline void to_json(json & j, const FenkClass & x) {
+        j = json::object();
+        j["apoise"] = x.get_apoise();
+        j["astronomize"] = x.get_astronomize();
+        j["cockhorse"] = x.get_cockhorse();
+        j["copular"] = x.get_copular();
+        j["Dagomba"] = x.get_dagomba();
+        j["draffy"] = x.get_draffy();
+        j["foreigner"] = x.get_foreigner();
+        j["Guyandot"] = x.get_guyandot();
+        j["neurogliosis"] = x.get_neurogliosis();
+        j["osmious"] = x.get_osmious();
+        j["palpitate"] = x.get_palpitate();
+        j["rebukeable"] = x.get_rebukeable();
+        j["Reinwardtia"] = x.get_reinwardtia();
+        j["reservatory"] = x.get_reservatory();
+        j["scalt"] = x.get_scalt();
+        j["scripturalize"] = x.get_scripturalize();
+        j["tintometer"] = x.get_tintometer();
+        j["Tritoness"] = x.get_tritoness();
+        j["undergrade"] = x.get_undergrade();
+        j["undermountain"] = x.get_undermountain();
+    }
+
+    inline void from_json(const json & j, FlagmakingClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_albarco(get_untyped(j, "albarco"));
+        x.set_bunodonta(get_untyped(j, "Bunodonta"));
+        x.set_hornify(get_untyped(j, "hornify"));
+        x.set_hydrocorisae(get_untyped(j, "Hydrocorisae"));
+        x.set_hypoglossus(get_untyped(j, "hypoglossus"));
+        x.set_inexpiably(get_untyped(j, "inexpiably"));
+        x.set_ingratitude(get_untyped(j, "ingratitude"));
+        x.set_ladyfly(get_untyped(j, "ladyfly"));
+        x.set_medicament(get_untyped(j, "medicament"));
+        x.set_monogrammatic(get_untyped(j, "monogrammatic"));
+        x.set_nobbut(get_untyped(j, "nobbut"));
+        x.set_notacanthidae(get_untyped(j, "Notacanthidae"));
+        x.set_polyplacophore(get_untyped(j, "polyplacophore"));
+        x.set_proexercise(get_untyped(j, "proexercise"));
+        x.set_protoplast(get_untyped(j, "protoplast"));
+        x.set_puzzling(get_untyped(j, "puzzling"));
+        x.set_splanchnoskeleton(get_untyped(j, "splanchnoskeleton"));
+        x.set_unloveliness(get_untyped(j, "unloveliness"));
+        x.set_unquarantined(get_untyped(j, "unquarantined"));
+        x.set_unrenounceable(get_untyped(j, "unrenounceable"));
+    }
+
+    inline void to_json(json & j, const FlagmakingClass & x) {
+        j = json::object();
+        j["albarco"] = x.get_albarco();
+        j["Bunodonta"] = x.get_bunodonta();
+        j["hornify"] = x.get_hornify();
+        j["Hydrocorisae"] = x.get_hydrocorisae();
+        j["hypoglossus"] = x.get_hypoglossus();
+        j["inexpiably"] = x.get_inexpiably();
+        j["ingratitude"] = x.get_ingratitude();
+        j["ladyfly"] = x.get_ladyfly();
+        j["medicament"] = x.get_medicament();
+        j["monogrammatic"] = x.get_monogrammatic();
+        j["nobbut"] = x.get_nobbut();
+        j["Notacanthidae"] = x.get_notacanthidae();
+        j["polyplacophore"] = x.get_polyplacophore();
+        j["proexercise"] = x.get_proexercise();
+        j["protoplast"] = x.get_protoplast();
+        j["puzzling"] = x.get_puzzling();
+        j["splanchnoskeleton"] = x.get_splanchnoskeleton();
+        j["unloveliness"] = x.get_unloveliness();
+        j["unquarantined"] = x.get_unquarantined();
+        j["unrenounceable"] = x.get_unrenounceable();
+    }
+
+    inline void from_json(const json & j, HemocoeleClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acrogamy(get_untyped(j, "acrogamy"));
+        x.set_amelification(get_untyped(j, "amelification"));
+        x.set_autobiographic(get_untyped(j, "autobiographic"));
+        x.set_berat(get_untyped(j, "berat"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_disproportionably(get_untyped(j, "disproportionably"));
+        x.set_erythrite(get_untyped(j, "erythrite"));
+        x.set_graphic(get_untyped(j, "graphic"));
+        x.set_hepatological(get_untyped(j, "hepatological"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_incommensurably(get_untyped(j, "incommensurably"));
+        x.set_misaffirm(get_untyped(j, "misaffirm"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_pocketbook(get_untyped(j, "pocketbook"));
+        x.set_sclerometric(get_untyped(j, "sclerometric"));
+        x.set_stambouline(get_untyped(j, "stambouline"));
+        x.set_stickpin(get_untyped(j, "stickpin"));
+        x.set_tubulure(get_untyped(j, "tubulure"));
+        x.set_undelated(get_untyped(j, "undelated"));
+        x.set_unsalt(get_untyped(j, "unsalt"));
+        x.set_untutelar(get_untyped(j, "untutelar"));
+        x.set_vagrant(get_untyped(j, "vagrant"));
+        x.set_walt(get_untyped(j, "Walt"));
+    }
+
+    inline void to_json(json & j, const HemocoeleClass & x) {
+        j = json::object();
+        j["acrogamy"] = x.get_acrogamy();
+        j["amelification"] = x.get_amelification();
+        j["autobiographic"] = x.get_autobiographic();
+        j["berat"] = x.get_berat();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["disproportionably"] = x.get_disproportionably();
+        j["erythrite"] = x.get_erythrite();
+        j["graphic"] = x.get_graphic();
+        j["hepatological"] = x.get_hepatological();
+        j["homocerc"] = x.get_homocerc();
+        j["incommensurably"] = x.get_incommensurably();
+        j["misaffirm"] = x.get_misaffirm();
+        j["nonbookish"] = x.get_nonbookish();
+        j["pocketbook"] = x.get_pocketbook();
+        j["sclerometric"] = x.get_sclerometric();
+        j["stambouline"] = x.get_stambouline();
+        j["stickpin"] = x.get_stickpin();
+        j["tubulure"] = x.get_tubulure();
+        j["undelated"] = x.get_undelated();
+        j["unsalt"] = x.get_unsalt();
+        j["untutelar"] = x.get_untutelar();
+        j["vagrant"] = x.get_vagrant();
+        j["Walt"] = x.get_walt();
+    }
+
+    inline void from_json(const json & j, Interacinar& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_assapan(j.at("assapan").get<double>());
+        x.set_benefactorship(j.at("benefactorship").get<bool>());
+        x.set_triseriatim(j.at("triseriatim").get<std::string>());
+        x.set_tubbing(j.at("tubbing").get<int64_t>());
+        x.set_untrimmed(get_untyped(j, "untrimmed"));
+    }
+
+    inline void to_json(json & j, const Interacinar & x) {
+        j = json::object();
+        j["assapan"] = x.get_assapan();
+        j["benefactorship"] = x.get_benefactorship();
+        j["triseriatim"] = x.get_triseriatim();
+        j["tubbing"] = x.get_tubbing();
+        j["untrimmed"] = x.get_untrimmed();
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_centrodesmose(j.at("centrodesmose").get<std::string>());
+        x.set_cerograph(j.at("cerograph").get<std::vector<CerographElement>>());
+        x.set_chemotherapeutics(j.at("chemotherapeutics").get<std::vector<ChemotherapeuticElement>>());
+        x.set_cimelia(j.at("cimelia").get<std::vector<CimeliaElement>>());
+        x.set_citrated(j.at("citrated").get<int64_t>());
+        x.set_clinodome(j.at("clinodome").get<std::vector<Clinodome>>());
+        x.set_coadjust(j.at("coadjust").get<std::vector<CoadjustElement>>());
+        x.set_consilience(j.at("consilience").get<std::vector<Consilience>>());
+        x.set_constructor(j.at("constructor").get<std::vector<Constructor>>());
+        x.set_continuative(j.at("continuative").get<std::vector<Continuative>>());
+        x.set_credulity(j.at("credulity").get<std::vector<CredulityElement>>());
+        x.set_creviced(j.at("creviced").get<std::vector<Creviced>>());
+        x.set_cubiculum(j.at("cubiculum").get<std::vector<std::vector<std::optional<int64_t>>>>());
+        x.set_deruralize(j.at("deruralize").get<std::vector<DeruralizeElement>>());
+        x.set_diaereses(j.at("diaereses").get<std::vector<DiaereseElement>>());
+        x.set_dissolution(j.at("dissolution").get<std::vector<std::optional<std::vector<nlohmann::json>>>>());
+        x.set_downstroke(j.at("downstroke").get<std::vector<Downstroke>>());
+        x.set_electrotautomerism(j.at("electrotautomerism").get<std::vector<std::optional<double>>>());
+        x.set_eleutheromania(j.at("eleutheromania").get<std::vector<Eleutheromania>>());
+        x.set_encrust(j.at("encrust").get<Encrust>());
+        x.set_entomoid(j.at("entomoid").get<std::vector<Entomoid>>());
+        x.set_epipaleolithic(j.at("epipaleolithic").get<std::vector<Epipaleolithic>>());
+        x.set_expropriable(j.at("expropriable").get<std::vector<Expropriable>>());
+        x.set_faggingly(j.at("faggingly").get<std::vector<FagginglyElement>>());
+        x.set_fenks(j.at("fenks").get<std::vector<FenkElement>>());
+        x.set_flagmaking(j.at("flagmaking").get<std::vector<FlagmakingElement>>());
+        x.set_fluorometer(j.at("fluorometer").get<std::vector<Fluorometer>>());
+        x.set_fulsome(j.at("fulsome").get<std::vector<std::optional<int64_t>>>());
+        x.set_fuzzy(j.at("fuzzy").get<std::vector<Fuzzy>>());
+        x.set_gardenwards(j.at("gardenwards").get<std::vector<Gardenward>>());
+        x.set_generalissimo(j.at("generalissimo").get<std::vector<Generalissimo>>());
+        x.set_habeas(j.at("habeas").get<std::vector<std::optional<std::map<std::string, int64_t>>>>());
+        x.set_hemicrystalline(j.at("hemicrystalline").get<std::vector<Hemicrystalline>>());
+        x.set_hemocoele(j.at("hemocoele").get<std::vector<HemocoeleElement>>());
+        x.set_hoister(j.at("hoister").get<std::vector<Hoister>>());
+        x.set_hyperpiesis(j.at("hyperpiesis").get<std::vector<Hyperpiesi>>());
+        x.set_hyppish(j.at("hyppish").get<std::vector<Hyppish>>());
+        x.set_idealizer(j.at("idealizer").get<std::vector<Idealizer>>());
+        x.set_incrustator(j.at("incrustator").get<std::vector<Incrustator>>());
+        x.set_intentiveness(j.at("intentiveness").get<std::vector<Intentiveness>>());
+        x.set_interacinar(j.at("interacinar").get<Interacinar>());
+        x.set_intercorrelation(j.at("intercorrelation").get<std::vector<std::optional<std::vector<int64_t>>>>());
+        x.set_jacutinga(j.at("jacutinga").get<std::vector<Jacutinga>>());
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["centrodesmose"] = x.get_centrodesmose();
+        j["cerograph"] = x.get_cerograph();
+        j["chemotherapeutics"] = x.get_chemotherapeutics();
+        j["cimelia"] = x.get_cimelia();
+        j["citrated"] = x.get_citrated();
+        j["clinodome"] = x.get_clinodome();
+        j["coadjust"] = x.get_coadjust();
+        j["consilience"] = x.get_consilience();
+        j["constructor"] = x.get_constructor();
+        j["continuative"] = x.get_continuative();
+        j["credulity"] = x.get_credulity();
+        j["creviced"] = x.get_creviced();
+        j["cubiculum"] = x.get_cubiculum();
+        j["deruralize"] = x.get_deruralize();
+        j["diaereses"] = x.get_diaereses();
+        j["dissolution"] = x.get_dissolution();
+        j["downstroke"] = x.get_downstroke();
+        j["electrotautomerism"] = x.get_electrotautomerism();
+        j["eleutheromania"] = x.get_eleutheromania();
+        j["encrust"] = x.get_encrust();
+        j["entomoid"] = x.get_entomoid();
+        j["epipaleolithic"] = x.get_epipaleolithic();
+        j["expropriable"] = x.get_expropriable();
+        j["faggingly"] = x.get_faggingly();
+        j["fenks"] = x.get_fenks();
+        j["flagmaking"] = x.get_flagmaking();
+        j["fluorometer"] = x.get_fluorometer();
+        j["fulsome"] = x.get_fulsome();
+        j["fuzzy"] = x.get_fuzzy();
+        j["gardenwards"] = x.get_gardenwards();
+        j["generalissimo"] = x.get_generalissimo();
+        j["habeas"] = x.get_habeas();
+        j["hemicrystalline"] = x.get_hemicrystalline();
+        j["hemocoele"] = x.get_hemocoele();
+        j["hoister"] = x.get_hoister();
+        j["hyperpiesis"] = x.get_hyperpiesis();
+        j["hyppish"] = x.get_hyppish();
+        j["idealizer"] = x.get_idealizer();
+        j["incrustator"] = x.get_incrustator();
+        j["intentiveness"] = x.get_intentiveness();
+        j["interacinar"] = x.get_interacinar();
+        j["intercorrelation"] = x.get_intercorrelation();
+        j["jacutinga"] = x.get_jacutinga();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<quicktype::CerographClass, std::string>>::from_json(const json & j, std::variant<quicktype::CerographClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CerographClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CerographClass, std::string>>::to_json(json & j, const std::variant<quicktype::CerographClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CerographClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>>::from_json(const json & j, std::variant<quicktype::ChemotherapeuticClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::ChemotherapeuticClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ChemotherapeuticClass, int64_t>>::to_json(json & j, const std::variant<quicktype::ChemotherapeuticClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ChemotherapeuticClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::CimeliaClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::CimeliaClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(const json & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, const std::variant<double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoadjustClass, double>>::from_json(const json & j, std::variant<quicktype::CoadjustClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CoadjustClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoadjustClass, double>>::to_json(json & j, const std::variant<quicktype::CoadjustClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CoadjustClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<bool, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>>::from_json(const json & j, std::variant<quicktype::CredulityClass, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CredulityClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CredulityClass, int64_t, std::string>>::to_json(json & j, const std::variant<quicktype::CredulityClass, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CredulityClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>>::from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::DeruralizeClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::DeruralizeClass>>::to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::DeruralizeClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::DeruralizeClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::DiaereseClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::DiaereseClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::DiaereseClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::string>>::from_json(const json & j, std::variant<std::vector<json>, bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::string>>::to_json(json & j, const std::variant<std::vector<json>, bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>>::from_json(const json & j, std::variant<quicktype::CimeliaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, int64_t>>::to_json(json & j, const std::variant<quicktype::CimeliaClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, double>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FagginglyClass, double>>::from_json(const json & j, std::variant<quicktype::FagginglyClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FagginglyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FagginglyClass, double>>::to_json(json & j, const std::variant<quicktype::FagginglyClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FagginglyClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FenkClass, std::string>>::from_json(const json & j, std::variant<quicktype::FenkClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::FenkClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FenkClass, std::string>>::to_json(json & j, const std::variant<quicktype::FenkClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FenkClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>>::from_json(const json & j, std::variant<bool, quicktype::FlagmakingClass, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FlagmakingClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::FlagmakingClass, double>>::to_json(json & j, const std::variant<bool, quicktype::FlagmakingClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::FlagmakingClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::from_json(const json & j, std::variant<int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::to_json(json & j, const std::variant<int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, std::string>>::from_json(const json & j, std::variant<quicktype::CimeliaClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, std::string>>::to_json(json & j, const std::variant<quicktype::CimeliaClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::HemocoeleClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::HemocoeleClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::HemocoeleClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::HemocoeleClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::from_json(const json & j, std::variant<bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::to_json(json & j, const std::variant<bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::CimeliaClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>>::from_json(const json & j, std::variant<quicktype::CimeliaClass, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::CimeliaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CimeliaClass, double, std::string>>::to_json(json & j, const std::variant<quicktype::CimeliaClass, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CimeliaClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations2.json/code-format-with-struct--67c848c66185/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations2.json/code-format-with-struct--67c848c66185/quicktype.hpp
new file mode 100644
index 0000000..d3724ac
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations2.json/code-format-with-struct--67c848c66185/quicktype.hpp
@@ -0,0 +1,1979 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    using Abranchiata = std::optional<std::variant<std::vector<int64_t>, int64_t>>;
+
+    using Academe = std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>;
+
+    using Acquirable = std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>;
+
+    using Aerometry = std::variant<bool, double>;
+
+    using Alexin = std::variant<std::vector<int64_t>, bool>;
+
+    struct AlleviateClass {
+        nlohmann::json apriori;
+        nlohmann::json beggarer;
+        nlohmann::json brokenheartedly;
+        nlohmann::json debilitation;
+        nlohmann::json frike;
+        nlohmann::json gastrolith;
+        nlohmann::json hulsean;
+        nlohmann::json orthocentric;
+        nlohmann::json petaly;
+        nlohmann::json probudgeting;
+        nlohmann::json reacquire;
+        nlohmann::json scow;
+        nlohmann::json shutoff;
+        nlohmann::json subcontiguous;
+        nlohmann::json suffumigate;
+        nlohmann::json transformable;
+        nlohmann::json uncoroneted;
+        nlohmann::json unparking;
+        nlohmann::json unvarnishedness;
+        nlohmann::json wherewithal;
+    };
+
+    using AlleviateElement = std::variant<std::vector<std::optional<int64_t>>, AlleviateClass>;
+
+    struct Rebecca {
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+    };
+
+    using Amaa = std::variant<bool, Rebecca, int64_t>;
+
+    using Ambassage = std::variant<std::vector<nlohmann::json>, std::string>;
+
+    struct Amphithyron {
+        std::optional<int64_t> akroasis;
+        std::optional<int64_t> antiphonical;
+        std::optional<int64_t> basebred;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> conductometric;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ensilation;
+        std::optional<int64_t> eyebolt;
+        std::optional<int64_t> fistulated;
+        std::optional<int64_t> heteropod;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> juniperus;
+        std::optional<int64_t> labyrinthically;
+        std::optional<int64_t> martyrization;
+        std::optional<int64_t> mispolicy;
+        std::optional<int64_t> multipara;
+        std::optional<int64_t> nazirite;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> possessorial;
+        std::optional<int64_t> shamed;
+        std::optional<int64_t> shelfworn;
+        std::optional<int64_t> stagnum;
+        std::optional<int64_t> those;
+        std::optional<int64_t> undecimal;
+    };
+
+    struct AnkeeClass {
+        nlohmann::json anomoean;
+        nlohmann::json barleyhood;
+        nlohmann::json befriender;
+        nlohmann::json brutishness;
+        nlohmann::json cephalalgy;
+        nlohmann::json cirurgian;
+        nlohmann::json conventionally;
+        nlohmann::json jackshay;
+        nlohmann::json milammeter;
+        nlohmann::json naja;
+        nlohmann::json ombrological;
+        nlohmann::json phonasthenia;
+        nlohmann::json retrievableness;
+        nlohmann::json snakily;
+        nlohmann::json swot;
+        nlohmann::json tartlet;
+        nlohmann::json thiofuran;
+        nlohmann::json tracheophone;
+        nlohmann::json tuglike;
+        nlohmann::json unscratchingly;
+    };
+
+    using AnkeeElement = std::variant<std::vector<int64_t>, AnkeeClass, int64_t>;
+
+    struct AnsarieClass {
+        nlohmann::json accension;
+        nlohmann::json alida;
+        nlohmann::json asteria;
+        nlohmann::json beriberic;
+        nlohmann::json edgebone;
+        nlohmann::json gastrodialysis;
+        nlohmann::json geographic;
+        nlohmann::json ictonyx;
+        nlohmann::json metrocele;
+        nlohmann::json misgraft;
+        nlohmann::json monteith;
+        nlohmann::json notcher;
+        nlohmann::json prorestriction;
+        nlohmann::json ramist;
+        nlohmann::json throatlet;
+        nlohmann::json unfair;
+        nlohmann::json unsynonymous;
+        nlohmann::json water;
+        nlohmann::json zestfully;
+        nlohmann::json zincic;
+    };
+
+    using AnsarieElement = std::optional<std::variant<std::vector<int64_t>, AnsarieClass>>;
+
+    using Aphasia = std::variant<std::vector<int64_t>, int64_t>;
+
+    using Asprawl = std::variant<double, std::string>;
+
+    using Bedesman = std::variant<bool, double, std::string>;
+
+    using Belard = std::variant<std::vector<int64_t>, Rebecca, double>;
+
+    using Bocking = std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>;
+
+    using Brawlingly = std::variant<std::vector<nlohmann::json>, std::map<std::string, std::optional<int64_t>>>;
+
+    using Brookie = std::variant<std::vector<int64_t>, Rebecca>;
+
+    using Bumboatman = std::optional<std::variant<std::vector<nlohmann::json>, std::string>>;
+
+    using Calaverite = std::variant<std::vector<int64_t>, std::string>;
+
+    using Catallactic = std::variant<std::vector<nlohmann::json>, bool, std::map<std::string, int64_t>>;
+
+    using Cemental = std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>;
+
+    struct ChytridiaceaeClass {
+        nlohmann::json batidaceae;
+        nlohmann::json brechites;
+        nlohmann::json codespairer;
+        nlohmann::json emery;
+        nlohmann::json enervative;
+        nlohmann::json excriminate;
+        nlohmann::json goshenite;
+        nlohmann::json grime;
+        nlohmann::json gritten;
+        nlohmann::json hectorly;
+        nlohmann::json intermediation;
+        nlohmann::json meeterly;
+        nlohmann::json narraganset;
+        nlohmann::json onymatic;
+        nlohmann::json paddlecock;
+        nlohmann::json thana;
+        nlohmann::json thornily;
+        nlohmann::json uckia;
+        nlohmann::json unmettle;
+        nlohmann::json vorticellid;
+    };
+
+    using ChytridiaceaeElement = std::optional<std::variant<bool, ChytridiaceaeClass>>;
+
+    struct DiscordiaClass {
+        std::optional<int64_t> altaic;
+        std::optional<int64_t> amoristic;
+        std::optional<int64_t> blennophthalmia;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> disciplinability;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> goofer;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> laryngograph;
+        std::optional<int64_t> leucitis;
+        std::optional<int64_t> lymphocyst;
+        std::optional<int64_t> microcosmology;
+        std::optional<int64_t> nauseation;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> patarin;
+        std::optional<int64_t> preliberal;
+        std::optional<int64_t> prettifier;
+        std::optional<int64_t> rangework;
+        std::optional<int64_t> redient;
+        std::optional<int64_t> subfusiform;
+        std::optional<int64_t> suicidical;
+        std::optional<int64_t> swow;
+        std::optional<int64_t> wastrel;
+        std::optional<int64_t> wingle;
+    };
+
+    using DiscordiaElement = std::variant<std::vector<int64_t>, DiscordiaClass>;
+
+    using Endomyce = std::variant<int64_t, std::string>;
+
+    using Epinephelidae = std::variant<bool, int64_t, std::string>;
+
+    using Eupatorium = std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>>;
+
+    struct GryphosaurusClass {
+        nlohmann::json amissibility;
+        nlohmann::json burushaski;
+        nlohmann::json citronin;
+        nlohmann::json coplaintiff;
+        nlohmann::json disquisitionary;
+        nlohmann::json enoplan;
+        nlohmann::json faintness;
+        nlohmann::json hebetomy;
+        nlohmann::json islandry;
+        nlohmann::json lameduck;
+        nlohmann::json overbattle;
+        nlohmann::json overinterested;
+        nlohmann::json phrenologic;
+        nlohmann::json rainband;
+        nlohmann::json shiningly;
+        nlohmann::json stamineous;
+        nlohmann::json subscapularis;
+        nlohmann::json tahami;
+        nlohmann::json undaubed;
+        nlohmann::json underntime;
+    };
+
+    using GryphosaurusElement = std::variant<std::vector<int64_t>, GryphosaurusClass, std::string>;
+
+    using Koryak = std::variant<std::map<std::string, std::optional<int64_t>>, std::string>;
+
+    struct LaviniaClass {
+        std::optional<int64_t> agitable;
+        std::optional<int64_t> asininity;
+        std::optional<int64_t> benefiter;
+        std::optional<int64_t> bronzelike;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> cholesteatomatous;
+        std::optional<int64_t> deprivement;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> flippantness;
+        std::optional<int64_t> fogproof;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> merrymeeting;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> overcareful;
+        std::optional<int64_t> panaris;
+        std::optional<int64_t> preacceptance;
+        std::optional<int64_t> quinoxaline;
+        std::optional<int64_t> sig;
+        std::optional<int64_t> superconfusion;
+        std::optional<int64_t> tacana;
+        std::optional<int64_t> tillotter;
+        std::optional<int64_t> tranquillize;
+        std::optional<int64_t> unquestionable;
+        std::optional<int64_t> uproute;
+    };
+
+    using LaviniaElement = std::variant<LaviniaClass, std::string>;
+
+    struct OskarClass {
+        nlohmann::json acrobates;
+        nlohmann::json beanshooter;
+        nlohmann::json bearhound;
+        nlohmann::json cayuga;
+        nlohmann::json guarneri;
+        nlohmann::json hypochondriacism;
+        nlohmann::json indication;
+        nlohmann::json jaculative;
+        nlohmann::json nagana;
+        nlohmann::json netherlandish;
+        nlohmann::json noctivagous;
+        nlohmann::json nonphysiological;
+        nlohmann::json praxis;
+        nlohmann::json provision;
+        nlohmann::json subterhuman;
+        nlohmann::json sunlit;
+        nlohmann::json syncraniate;
+        nlohmann::json teachment;
+        nlohmann::json unmutinous;
+        nlohmann::json unstoppable;
+    };
+
+    using OskarElement = std::variant<std::vector<int64_t>, OskarClass>;
+
+    using RebeccaElement = std::variant<Rebecca, int64_t, std::string>;
+
+    using Rhomboganoidei = std::variant<std::vector<int64_t>, Rebecca, std::string>;
+
+    using Ruellia = std::variant<bool, Rebecca, std::string>;
+
+    using School = std::optional<std::variant<int64_t, std::map<std::string, int64_t>>>;
+
+    using Shakespearolater = std::variant<std::vector<int64_t>, double, std::string>;
+
+    struct TopLevel {
+        std::vector<Abranchiata> abranchiata;
+        std::vector<Academe> academe;
+        std::vector<Acquirable> acquirable;
+        std::vector<Aerometry> aerometry;
+        std::vector<Alexin> alexin;
+        std::vector<AlleviateElement> alleviate;
+        std::vector<Amaa> amaas;
+        std::vector<Ambassage> ambassage;
+        std::vector<std::optional<Amphithyron>> amphithyron;
+        std::vector<std::optional<std::string>> andriana;
+        std::vector<AnkeeElement> ankee;
+        std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> annihilator;
+        nlohmann::json annulose;
+        std::vector<AnsarieElement> ansarie;
+        std::vector<Aphasia> aphasia;
+        std::vector<Asprawl> asprawl;
+        std::vector<std::optional<bool>> attractive;
+        std::map<std::string, int64_t> barksome;
+        std::vector<Bedesman> bedesman;
+        std::vector<Belard> belard;
+        std::vector<Bocking> bocking;
+        std::vector<Brawlingly> brawlingly;
+        std::vector<Brookie> brookie;
+        std::vector<Bumboatman> bumboatman;
+        std::vector<nlohmann::json> bystreet;
+        std::vector<Calaverite> calaverite;
+        std::vector<Catallactic> catallactic;
+        std::vector<Cemental> cemental;
+        std::vector<ChytridiaceaeElement> chytridiaceae;
+        std::vector<DiscordiaElement> discordia;
+        std::vector<Endomyce> endomyces;
+        std::vector<Epinephelidae> epinephelidae;
+        std::vector<Eupatorium> eupatorium;
+        std::vector<GryphosaurusElement> gryphosaurus;
+        std::vector<Koryak> koryak;
+        std::vector<LaviniaElement> lavinia;
+        std::vector<OskarElement> oskar;
+        std::vector<RebeccaElement> rebecca;
+        std::vector<Rhomboganoidei> rhomboganoidei;
+        bool rigsmal;
+        std::vector<Ruellia> ruellia;
+        std::vector<School> school;
+        std::vector<Shakespearolater> shakespearolater;
+        std::vector<double> svan;
+        std::map<std::string, double> wayao;
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, AlleviateClass & x);
+void to_json(json & j, const AlleviateClass & x);
+
+void from_json(const json & j, Rebecca & x);
+void to_json(json & j, const Rebecca & x);
+
+void from_json(const json & j, Amphithyron & x);
+void to_json(json & j, const Amphithyron & x);
+
+void from_json(const json & j, AnkeeClass & x);
+void to_json(json & j, const AnkeeClass & x);
+
+void from_json(const json & j, AnsarieClass & x);
+void to_json(json & j, const AnsarieClass & x);
+
+void from_json(const json & j, ChytridiaceaeClass & x);
+void to_json(json & j, const ChytridiaceaeClass & x);
+
+void from_json(const json & j, DiscordiaClass & x);
+void to_json(json & j, const DiscordiaClass & x);
+
+void from_json(const json & j, GryphosaurusClass & x);
+void to_json(json & j, const GryphosaurusClass & x);
+
+void from_json(const json & j, LaviniaClass & x);
+void to_json(json & j, const LaviniaClass & x);
+
+void from_json(const json & j, OskarClass & x);
+void to_json(json & j, const OskarClass & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(const json & j, std::variant<bool, double> & x);
+    static void to_json(json & j, const std::variant<bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::Rebecca, int64_t> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::Rebecca, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double, std::string>> {
+    static void from_json(const json & j, std::variant<bool, double, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::ChytridiaceaeClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::ChytridiaceaeClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<bool, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>> {
+    static void from_json(const json & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LaviniaClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::LaviniaClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::LaviniaClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::OskarClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::Rebecca, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::Rebecca, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::Rebecca, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::Rebecca, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double, std::string> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, AlleviateClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.apriori = get_untyped(j, "apriori");
+        x.beggarer = get_untyped(j, "beggarer");
+        x.brokenheartedly = get_untyped(j, "brokenheartedly");
+        x.debilitation = get_untyped(j, "debilitation");
+        x.frike = get_untyped(j, "frike");
+        x.gastrolith = get_untyped(j, "gastrolith");
+        x.hulsean = get_untyped(j, "Hulsean");
+        x.orthocentric = get_untyped(j, "orthocentric");
+        x.petaly = get_untyped(j, "petaly");
+        x.probudgeting = get_untyped(j, "probudgeting");
+        x.reacquire = get_untyped(j, "reacquire");
+        x.scow = get_untyped(j, "scow");
+        x.shutoff = get_untyped(j, "shutoff");
+        x.subcontiguous = get_untyped(j, "subcontiguous");
+        x.suffumigate = get_untyped(j, "suffumigate");
+        x.transformable = get_untyped(j, "transformable");
+        x.uncoroneted = get_untyped(j, "uncoroneted");
+        x.unparking = get_untyped(j, "unparking");
+        x.unvarnishedness = get_untyped(j, "unvarnishedness");
+        x.wherewithal = get_untyped(j, "wherewithal");
+    }
+
+    inline void to_json(json & j, const AlleviateClass & x) {
+        j = json::object();
+        j["apriori"] = x.apriori;
+        j["beggarer"] = x.beggarer;
+        j["brokenheartedly"] = x.brokenheartedly;
+        j["debilitation"] = x.debilitation;
+        j["frike"] = x.frike;
+        j["gastrolith"] = x.gastrolith;
+        j["Hulsean"] = x.hulsean;
+        j["orthocentric"] = x.orthocentric;
+        j["petaly"] = x.petaly;
+        j["probudgeting"] = x.probudgeting;
+        j["reacquire"] = x.reacquire;
+        j["scow"] = x.scow;
+        j["shutoff"] = x.shutoff;
+        j["subcontiguous"] = x.subcontiguous;
+        j["suffumigate"] = x.suffumigate;
+        j["transformable"] = x.transformable;
+        j["uncoroneted"] = x.uncoroneted;
+        j["unparking"] = x.unparking;
+        j["unvarnishedness"] = x.unvarnishedness;
+        j["wherewithal"] = x.wherewithal;
+    }
+
+    inline void from_json(const json & j, Rebecca& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.catharticalness = j.at("catharticalness").get<double>();
+        x.chirotherium = j.at("Chirotherium").get<int64_t>();
+        x.disdiapason = j.at("disdiapason").get<std::string>();
+        x.homocerc = j.at("homocerc").get<bool>();
+        x.nonbookish = get_untyped(j, "nonbookish");
+    }
+
+    inline void to_json(json & j, const Rebecca & x) {
+        j = json::object();
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["homocerc"] = x.homocerc;
+        j["nonbookish"] = x.nonbookish;
+    }
+
+    inline void from_json(const json & j, Amphithyron& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.akroasis = get_stack_optional<int64_t>(j, "akroasis");
+        x.antiphonical = get_stack_optional<int64_t>(j, "antiphonical");
+        x.basebred = get_stack_optional<int64_t>(j, "basebred");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.conductometric = get_stack_optional<int64_t>(j, "conductometric");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.ensilation = get_stack_optional<int64_t>(j, "ensilation");
+        x.eyebolt = get_stack_optional<int64_t>(j, "eyebolt");
+        x.fistulated = get_stack_optional<int64_t>(j, "fistulated");
+        x.heteropod = get_stack_optional<int64_t>(j, "heteropod");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.juniperus = get_stack_optional<int64_t>(j, "Juniperus");
+        x.labyrinthically = get_stack_optional<int64_t>(j, "labyrinthically");
+        x.martyrization = get_stack_optional<int64_t>(j, "martyrization");
+        x.mispolicy = get_stack_optional<int64_t>(j, "mispolicy");
+        x.multipara = get_stack_optional<int64_t>(j, "multipara");
+        x.nazirite = get_stack_optional<int64_t>(j, "Nazirite");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.possessorial = get_stack_optional<int64_t>(j, "possessorial");
+        x.shamed = get_stack_optional<int64_t>(j, "shamed");
+        x.shelfworn = get_stack_optional<int64_t>(j, "shelfworn");
+        x.stagnum = get_stack_optional<int64_t>(j, "stagnum");
+        x.those = get_stack_optional<int64_t>(j, "Those");
+        x.undecimal = get_stack_optional<int64_t>(j, "undecimal");
+    }
+
+    inline void to_json(json & j, const Amphithyron & x) {
+        j = json::object();
+        j["akroasis"] = x.akroasis;
+        j["antiphonical"] = x.antiphonical;
+        j["basebred"] = x.basebred;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["conductometric"] = x.conductometric;
+        j["disdiapason"] = x.disdiapason;
+        j["ensilation"] = x.ensilation;
+        j["eyebolt"] = x.eyebolt;
+        j["fistulated"] = x.fistulated;
+        j["heteropod"] = x.heteropod;
+        j["homocerc"] = x.homocerc;
+        j["Juniperus"] = x.juniperus;
+        j["labyrinthically"] = x.labyrinthically;
+        j["martyrization"] = x.martyrization;
+        j["mispolicy"] = x.mispolicy;
+        j["multipara"] = x.multipara;
+        j["Nazirite"] = x.nazirite;
+        j["nonbookish"] = x.nonbookish;
+        j["possessorial"] = x.possessorial;
+        j["shamed"] = x.shamed;
+        j["shelfworn"] = x.shelfworn;
+        j["stagnum"] = x.stagnum;
+        j["Those"] = x.those;
+        j["undecimal"] = x.undecimal;
+    }
+
+    inline void from_json(const json & j, AnkeeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.anomoean = get_untyped(j, "Anomoean");
+        x.barleyhood = get_untyped(j, "barleyhood");
+        x.befriender = get_untyped(j, "befriender");
+        x.brutishness = get_untyped(j, "brutishness");
+        x.cephalalgy = get_untyped(j, "cephalalgy");
+        x.cirurgian = get_untyped(j, "cirurgian");
+        x.conventionally = get_untyped(j, "conventionally");
+        x.jackshay = get_untyped(j, "jackshay");
+        x.milammeter = get_untyped(j, "milammeter");
+        x.naja = get_untyped(j, "Naja");
+        x.ombrological = get_untyped(j, "ombrological");
+        x.phonasthenia = get_untyped(j, "phonasthenia");
+        x.retrievableness = get_untyped(j, "retrievableness");
+        x.snakily = get_untyped(j, "snakily");
+        x.swot = get_untyped(j, "swot");
+        x.tartlet = get_untyped(j, "tartlet");
+        x.thiofuran = get_untyped(j, "thiofuran");
+        x.tracheophone = get_untyped(j, "tracheophone");
+        x.tuglike = get_untyped(j, "tuglike");
+        x.unscratchingly = get_untyped(j, "unscratchingly");
+    }
+
+    inline void to_json(json & j, const AnkeeClass & x) {
+        j = json::object();
+        j["Anomoean"] = x.anomoean;
+        j["barleyhood"] = x.barleyhood;
+        j["befriender"] = x.befriender;
+        j["brutishness"] = x.brutishness;
+        j["cephalalgy"] = x.cephalalgy;
+        j["cirurgian"] = x.cirurgian;
+        j["conventionally"] = x.conventionally;
+        j["jackshay"] = x.jackshay;
+        j["milammeter"] = x.milammeter;
+        j["Naja"] = x.naja;
+        j["ombrological"] = x.ombrological;
+        j["phonasthenia"] = x.phonasthenia;
+        j["retrievableness"] = x.retrievableness;
+        j["snakily"] = x.snakily;
+        j["swot"] = x.swot;
+        j["tartlet"] = x.tartlet;
+        j["thiofuran"] = x.thiofuran;
+        j["tracheophone"] = x.tracheophone;
+        j["tuglike"] = x.tuglike;
+        j["unscratchingly"] = x.unscratchingly;
+    }
+
+    inline void from_json(const json & j, AnsarieClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.accension = get_untyped(j, "accension");
+        x.alida = get_untyped(j, "Alida");
+        x.asteria = get_untyped(j, "asteria");
+        x.beriberic = get_untyped(j, "beriberic");
+        x.edgebone = get_untyped(j, "edgebone");
+        x.gastrodialysis = get_untyped(j, "gastrodialysis");
+        x.geographic = get_untyped(j, "geographic");
+        x.ictonyx = get_untyped(j, "Ictonyx");
+        x.metrocele = get_untyped(j, "metrocele");
+        x.misgraft = get_untyped(j, "misgraft");
+        x.monteith = get_untyped(j, "monteith");
+        x.notcher = get_untyped(j, "notcher");
+        x.prorestriction = get_untyped(j, "prorestriction");
+        x.ramist = get_untyped(j, "Ramist");
+        x.throatlet = get_untyped(j, "throatlet");
+        x.unfair = get_untyped(j, "unfair");
+        x.unsynonymous = get_untyped(j, "unsynonymous");
+        x.water = get_untyped(j, "water");
+        x.zestfully = get_untyped(j, "zestfully");
+        x.zincic = get_untyped(j, "zincic");
+    }
+
+    inline void to_json(json & j, const AnsarieClass & x) {
+        j = json::object();
+        j["accension"] = x.accension;
+        j["Alida"] = x.alida;
+        j["asteria"] = x.asteria;
+        j["beriberic"] = x.beriberic;
+        j["edgebone"] = x.edgebone;
+        j["gastrodialysis"] = x.gastrodialysis;
+        j["geographic"] = x.geographic;
+        j["Ictonyx"] = x.ictonyx;
+        j["metrocele"] = x.metrocele;
+        j["misgraft"] = x.misgraft;
+        j["monteith"] = x.monteith;
+        j["notcher"] = x.notcher;
+        j["prorestriction"] = x.prorestriction;
+        j["Ramist"] = x.ramist;
+        j["throatlet"] = x.throatlet;
+        j["unfair"] = x.unfair;
+        j["unsynonymous"] = x.unsynonymous;
+        j["water"] = x.water;
+        j["zestfully"] = x.zestfully;
+        j["zincic"] = x.zincic;
+    }
+
+    inline void from_json(const json & j, ChytridiaceaeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.batidaceae = get_untyped(j, "Batidaceae");
+        x.brechites = get_untyped(j, "Brechites");
+        x.codespairer = get_untyped(j, "codespairer");
+        x.emery = get_untyped(j, "Emery");
+        x.enervative = get_untyped(j, "enervative");
+        x.excriminate = get_untyped(j, "excriminate");
+        x.goshenite = get_untyped(j, "goshenite");
+        x.grime = get_untyped(j, "grime");
+        x.gritten = get_untyped(j, "gritten");
+        x.hectorly = get_untyped(j, "hectorly");
+        x.intermediation = get_untyped(j, "intermediation");
+        x.meeterly = get_untyped(j, "meeterly");
+        x.narraganset = get_untyped(j, "Narraganset");
+        x.onymatic = get_untyped(j, "onymatic");
+        x.paddlecock = get_untyped(j, "paddlecock");
+        x.thana = get_untyped(j, "thana");
+        x.thornily = get_untyped(j, "thornily");
+        x.uckia = get_untyped(j, "uckia");
+        x.unmettle = get_untyped(j, "unmettle");
+        x.vorticellid = get_untyped(j, "vorticellid");
+    }
+
+    inline void to_json(json & j, const ChytridiaceaeClass & x) {
+        j = json::object();
+        j["Batidaceae"] = x.batidaceae;
+        j["Brechites"] = x.brechites;
+        j["codespairer"] = x.codespairer;
+        j["Emery"] = x.emery;
+        j["enervative"] = x.enervative;
+        j["excriminate"] = x.excriminate;
+        j["goshenite"] = x.goshenite;
+        j["grime"] = x.grime;
+        j["gritten"] = x.gritten;
+        j["hectorly"] = x.hectorly;
+        j["intermediation"] = x.intermediation;
+        j["meeterly"] = x.meeterly;
+        j["Narraganset"] = x.narraganset;
+        j["onymatic"] = x.onymatic;
+        j["paddlecock"] = x.paddlecock;
+        j["thana"] = x.thana;
+        j["thornily"] = x.thornily;
+        j["uckia"] = x.uckia;
+        j["unmettle"] = x.unmettle;
+        j["vorticellid"] = x.vorticellid;
+    }
+
+    inline void from_json(const json & j, DiscordiaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.altaic = get_stack_optional<int64_t>(j, "Altaic");
+        x.amoristic = get_stack_optional<int64_t>(j, "amoristic");
+        x.blennophthalmia = get_stack_optional<int64_t>(j, "blennophthalmia");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.disciplinability = get_stack_optional<int64_t>(j, "disciplinability");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.goofer = get_stack_optional<int64_t>(j, "goofer");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.laryngograph = get_stack_optional<int64_t>(j, "laryngograph");
+        x.leucitis = get_stack_optional<int64_t>(j, "leucitis");
+        x.lymphocyst = get_stack_optional<int64_t>(j, "lymphocyst");
+        x.microcosmology = get_stack_optional<int64_t>(j, "microcosmology");
+        x.nauseation = get_stack_optional<int64_t>(j, "nauseation");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.patarin = get_stack_optional<int64_t>(j, "Patarin");
+        x.preliberal = get_stack_optional<int64_t>(j, "preliberal");
+        x.prettifier = get_stack_optional<int64_t>(j, "prettifier");
+        x.rangework = get_stack_optional<int64_t>(j, "rangework");
+        x.redient = get_stack_optional<int64_t>(j, "redient");
+        x.subfusiform = get_stack_optional<int64_t>(j, "subfusiform");
+        x.suicidical = get_stack_optional<int64_t>(j, "suicidical");
+        x.swow = get_stack_optional<int64_t>(j, "swow");
+        x.wastrel = get_stack_optional<int64_t>(j, "wastrel");
+        x.wingle = get_stack_optional<int64_t>(j, "wingle");
+    }
+
+    inline void to_json(json & j, const DiscordiaClass & x) {
+        j = json::object();
+        j["Altaic"] = x.altaic;
+        j["amoristic"] = x.amoristic;
+        j["blennophthalmia"] = x.blennophthalmia;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disciplinability"] = x.disciplinability;
+        j["disdiapason"] = x.disdiapason;
+        j["goofer"] = x.goofer;
+        j["homocerc"] = x.homocerc;
+        j["laryngograph"] = x.laryngograph;
+        j["leucitis"] = x.leucitis;
+        j["lymphocyst"] = x.lymphocyst;
+        j["microcosmology"] = x.microcosmology;
+        j["nauseation"] = x.nauseation;
+        j["nonbookish"] = x.nonbookish;
+        j["Patarin"] = x.patarin;
+        j["preliberal"] = x.preliberal;
+        j["prettifier"] = x.prettifier;
+        j["rangework"] = x.rangework;
+        j["redient"] = x.redient;
+        j["subfusiform"] = x.subfusiform;
+        j["suicidical"] = x.suicidical;
+        j["swow"] = x.swow;
+        j["wastrel"] = x.wastrel;
+        j["wingle"] = x.wingle;
+    }
+
+    inline void from_json(const json & j, GryphosaurusClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.amissibility = get_untyped(j, "amissibility");
+        x.burushaski = get_untyped(j, "Burushaski");
+        x.citronin = get_untyped(j, "citronin");
+        x.coplaintiff = get_untyped(j, "coplaintiff");
+        x.disquisitionary = get_untyped(j, "disquisitionary");
+        x.enoplan = get_untyped(j, "enoplan");
+        x.faintness = get_untyped(j, "faintness");
+        x.hebetomy = get_untyped(j, "hebetomy");
+        x.islandry = get_untyped(j, "islandry");
+        x.lameduck = get_untyped(j, "lameduck");
+        x.overbattle = get_untyped(j, "overbattle");
+        x.overinterested = get_untyped(j, "overinterested");
+        x.phrenologic = get_untyped(j, "phrenologic");
+        x.rainband = get_untyped(j, "rainband");
+        x.shiningly = get_untyped(j, "shiningly");
+        x.stamineous = get_untyped(j, "stamineous");
+        x.subscapularis = get_untyped(j, "subscapularis");
+        x.tahami = get_untyped(j, "Tahami");
+        x.undaubed = get_untyped(j, "undaubed");
+        x.underntime = get_untyped(j, "underntime");
+    }
+
+    inline void to_json(json & j, const GryphosaurusClass & x) {
+        j = json::object();
+        j["amissibility"] = x.amissibility;
+        j["Burushaski"] = x.burushaski;
+        j["citronin"] = x.citronin;
+        j["coplaintiff"] = x.coplaintiff;
+        j["disquisitionary"] = x.disquisitionary;
+        j["enoplan"] = x.enoplan;
+        j["faintness"] = x.faintness;
+        j["hebetomy"] = x.hebetomy;
+        j["islandry"] = x.islandry;
+        j["lameduck"] = x.lameduck;
+        j["overbattle"] = x.overbattle;
+        j["overinterested"] = x.overinterested;
+        j["phrenologic"] = x.phrenologic;
+        j["rainband"] = x.rainband;
+        j["shiningly"] = x.shiningly;
+        j["stamineous"] = x.stamineous;
+        j["subscapularis"] = x.subscapularis;
+        j["Tahami"] = x.tahami;
+        j["undaubed"] = x.undaubed;
+        j["underntime"] = x.underntime;
+    }
+
+    inline void from_json(const json & j, LaviniaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.agitable = get_stack_optional<int64_t>(j, "agitable");
+        x.asininity = get_stack_optional<int64_t>(j, "asininity");
+        x.benefiter = get_stack_optional<int64_t>(j, "benefiter");
+        x.bronzelike = get_stack_optional<int64_t>(j, "bronzelike");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.cholesteatomatous = get_stack_optional<int64_t>(j, "cholesteatomatous");
+        x.deprivement = get_stack_optional<int64_t>(j, "deprivement");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.flippantness = get_stack_optional<int64_t>(j, "flippantness");
+        x.fogproof = get_stack_optional<int64_t>(j, "fogproof");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.merrymeeting = get_stack_optional<int64_t>(j, "merrymeeting");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.overcareful = get_stack_optional<int64_t>(j, "overcareful");
+        x.panaris = get_stack_optional<int64_t>(j, "panaris");
+        x.preacceptance = get_stack_optional<int64_t>(j, "preacceptance");
+        x.quinoxaline = get_stack_optional<int64_t>(j, "quinoxaline");
+        x.sig = get_stack_optional<int64_t>(j, "sig");
+        x.superconfusion = get_stack_optional<int64_t>(j, "superconfusion");
+        x.tacana = get_stack_optional<int64_t>(j, "Tacana");
+        x.tillotter = get_stack_optional<int64_t>(j, "tillotter");
+        x.tranquillize = get_stack_optional<int64_t>(j, "tranquillize");
+        x.unquestionable = get_stack_optional<int64_t>(j, "unquestionable");
+        x.uproute = get_stack_optional<int64_t>(j, "uproute");
+    }
+
+    inline void to_json(json & j, const LaviniaClass & x) {
+        j = json::object();
+        j["agitable"] = x.agitable;
+        j["asininity"] = x.asininity;
+        j["benefiter"] = x.benefiter;
+        j["bronzelike"] = x.bronzelike;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["cholesteatomatous"] = x.cholesteatomatous;
+        j["deprivement"] = x.deprivement;
+        j["disdiapason"] = x.disdiapason;
+        j["flippantness"] = x.flippantness;
+        j["fogproof"] = x.fogproof;
+        j["homocerc"] = x.homocerc;
+        j["merrymeeting"] = x.merrymeeting;
+        j["nonbookish"] = x.nonbookish;
+        j["overcareful"] = x.overcareful;
+        j["panaris"] = x.panaris;
+        j["preacceptance"] = x.preacceptance;
+        j["quinoxaline"] = x.quinoxaline;
+        j["sig"] = x.sig;
+        j["superconfusion"] = x.superconfusion;
+        j["Tacana"] = x.tacana;
+        j["tillotter"] = x.tillotter;
+        j["tranquillize"] = x.tranquillize;
+        j["unquestionable"] = x.unquestionable;
+        j["uproute"] = x.uproute;
+    }
+
+    inline void from_json(const json & j, OskarClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.acrobates = get_untyped(j, "Acrobates");
+        x.beanshooter = get_untyped(j, "beanshooter");
+        x.bearhound = get_untyped(j, "bearhound");
+        x.cayuga = get_untyped(j, "Cayuga");
+        x.guarneri = get_untyped(j, "guarneri");
+        x.hypochondriacism = get_untyped(j, "hypochondriacism");
+        x.indication = get_untyped(j, "indication");
+        x.jaculative = get_untyped(j, "jaculative");
+        x.nagana = get_untyped(j, "nagana");
+        x.netherlandish = get_untyped(j, "Netherlandish");
+        x.noctivagous = get_untyped(j, "noctivagous");
+        x.nonphysiological = get_untyped(j, "nonphysiological");
+        x.praxis = get_untyped(j, "praxis");
+        x.provision = get_untyped(j, "provision");
+        x.subterhuman = get_untyped(j, "subterhuman");
+        x.sunlit = get_untyped(j, "sunlit");
+        x.syncraniate = get_untyped(j, "syncraniate");
+        x.teachment = get_untyped(j, "teachment");
+        x.unmutinous = get_untyped(j, "unmutinous");
+        x.unstoppable = get_untyped(j, "unstoppable");
+    }
+
+    inline void to_json(json & j, const OskarClass & x) {
+        j = json::object();
+        j["Acrobates"] = x.acrobates;
+        j["beanshooter"] = x.beanshooter;
+        j["bearhound"] = x.bearhound;
+        j["Cayuga"] = x.cayuga;
+        j["guarneri"] = x.guarneri;
+        j["hypochondriacism"] = x.hypochondriacism;
+        j["indication"] = x.indication;
+        j["jaculative"] = x.jaculative;
+        j["nagana"] = x.nagana;
+        j["Netherlandish"] = x.netherlandish;
+        j["noctivagous"] = x.noctivagous;
+        j["nonphysiological"] = x.nonphysiological;
+        j["praxis"] = x.praxis;
+        j["provision"] = x.provision;
+        j["subterhuman"] = x.subterhuman;
+        j["sunlit"] = x.sunlit;
+        j["syncraniate"] = x.syncraniate;
+        j["teachment"] = x.teachment;
+        j["unmutinous"] = x.unmutinous;
+        j["unstoppable"] = x.unstoppable;
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.abranchiata = j.at("Abranchiata").get<std::vector<Abranchiata>>();
+        x.academe = j.at("academe").get<std::vector<Academe>>();
+        x.acquirable = j.at("acquirable").get<std::vector<Acquirable>>();
+        x.aerometry = j.at("aerometry").get<std::vector<Aerometry>>();
+        x.alexin = j.at("alexin").get<std::vector<Alexin>>();
+        x.alleviate = j.at("alleviate").get<std::vector<AlleviateElement>>();
+        x.amaas = j.at("amaas").get<std::vector<Amaa>>();
+        x.ambassage = j.at("ambassage").get<std::vector<Ambassage>>();
+        x.amphithyron = j.at("amphithyron").get<std::vector<std::optional<Amphithyron>>>();
+        x.andriana = j.at("Andriana").get<std::vector<std::optional<std::string>>>();
+        x.ankee = j.at("ankee").get<std::vector<AnkeeElement>>();
+        x.annihilator = j.at("annihilator").get<std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>>>();
+        x.annulose = get_untyped(j, "annulose");
+        x.ansarie = j.at("Ansarie").get<std::vector<AnsarieElement>>();
+        x.aphasia = j.at("aphasia").get<std::vector<Aphasia>>();
+        x.asprawl = j.at("asprawl").get<std::vector<Asprawl>>();
+        x.attractive = j.at("attractive").get<std::vector<std::optional<bool>>>();
+        x.barksome = j.at("barksome").get<std::map<std::string, int64_t>>();
+        x.bedesman = j.at("bedesman").get<std::vector<Bedesman>>();
+        x.belard = j.at("belard").get<std::vector<Belard>>();
+        x.bocking = j.at("bocking").get<std::vector<Bocking>>();
+        x.brawlingly = j.at("brawlingly").get<std::vector<Brawlingly>>();
+        x.brookie = j.at("brookie").get<std::vector<Brookie>>();
+        x.bumboatman = j.at("bumboatman").get<std::vector<Bumboatman>>();
+        x.bystreet = j.at("bystreet").get<std::vector<nlohmann::json>>();
+        x.calaverite = j.at("calaverite").get<std::vector<Calaverite>>();
+        x.catallactic = j.at("catallactic").get<std::vector<Catallactic>>();
+        x.cemental = j.at("cemental").get<std::vector<Cemental>>();
+        x.chytridiaceae = j.at("Chytridiaceae").get<std::vector<ChytridiaceaeElement>>();
+        x.discordia = j.at("Discordia").get<std::vector<DiscordiaElement>>();
+        x.endomyces = j.at("Endomyces").get<std::vector<Endomyce>>();
+        x.epinephelidae = j.at("Epinephelidae").get<std::vector<Epinephelidae>>();
+        x.eupatorium = j.at("Eupatorium").get<std::vector<Eupatorium>>();
+        x.gryphosaurus = j.at("Gryphosaurus").get<std::vector<GryphosaurusElement>>();
+        x.koryak = j.at("Koryak").get<std::vector<Koryak>>();
+        x.lavinia = j.at("Lavinia").get<std::vector<LaviniaElement>>();
+        x.oskar = j.at("Oskar").get<std::vector<OskarElement>>();
+        x.rebecca = j.at("Rebecca").get<std::vector<RebeccaElement>>();
+        x.rhomboganoidei = j.at("Rhomboganoidei").get<std::vector<Rhomboganoidei>>();
+        x.rigsmal = j.at("Rigsmal").get<bool>();
+        x.ruellia = j.at("Ruellia").get<std::vector<Ruellia>>();
+        x.school = j.at("School").get<std::vector<School>>();
+        x.shakespearolater = j.at("Shakespearolater").get<std::vector<Shakespearolater>>();
+        x.svan = j.at("Svan").get<std::vector<double>>();
+        x.wayao = j.at("Wayao").get<std::map<std::string, double>>();
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["Abranchiata"] = x.abranchiata;
+        j["academe"] = x.academe;
+        j["acquirable"] = x.acquirable;
+        j["aerometry"] = x.aerometry;
+        j["alexin"] = x.alexin;
+        j["alleviate"] = x.alleviate;
+        j["amaas"] = x.amaas;
+        j["ambassage"] = x.ambassage;
+        j["amphithyron"] = x.amphithyron;
+        j["Andriana"] = x.andriana;
+        j["ankee"] = x.ankee;
+        j["annihilator"] = x.annihilator;
+        j["annulose"] = x.annulose;
+        j["Ansarie"] = x.ansarie;
+        j["aphasia"] = x.aphasia;
+        j["asprawl"] = x.asprawl;
+        j["attractive"] = x.attractive;
+        j["barksome"] = x.barksome;
+        j["bedesman"] = x.bedesman;
+        j["belard"] = x.belard;
+        j["bocking"] = x.bocking;
+        j["brawlingly"] = x.brawlingly;
+        j["brookie"] = x.brookie;
+        j["bumboatman"] = x.bumboatman;
+        j["bystreet"] = x.bystreet;
+        j["calaverite"] = x.calaverite;
+        j["catallactic"] = x.catallactic;
+        j["cemental"] = x.cemental;
+        j["Chytridiaceae"] = x.chytridiaceae;
+        j["Discordia"] = x.discordia;
+        j["Endomyces"] = x.endomyces;
+        j["Epinephelidae"] = x.epinephelidae;
+        j["Eupatorium"] = x.eupatorium;
+        j["Gryphosaurus"] = x.gryphosaurus;
+        j["Koryak"] = x.koryak;
+        j["Lavinia"] = x.lavinia;
+        j["Oskar"] = x.oskar;
+        j["Rebecca"] = x.rebecca;
+        j["Rhomboganoidei"] = x.rhomboganoidei;
+        j["Rigsmal"] = x.rigsmal;
+        j["Ruellia"] = x.ruellia;
+        j["School"] = x.school;
+        j["Shakespearolater"] = x.shakespearolater;
+        j["Svan"] = x.svan;
+        j["Wayao"] = x.wayao;
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(const json & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, const std::variant<bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::AlleviateClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AlleviateClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>>::from_json(const json & j, std::variant<bool, quicktype::Rebecca, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>>::to_json(json & j, const std::variant<bool, quicktype::Rebecca, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::string>>::from_json(const json & j, std::variant<std::vector<json>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::string>>::to_json(json & j, const std::variant<std::vector<json>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::AnkeeClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AnkeeClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::AnsarieClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AnsarieClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(const json & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, const std::variant<double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::string>>::from_json(const json & j, std::variant<bool, double, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::string>>::to_json(json & j, const std::variant<bool, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>>::from_json(const json & j, std::variant<bool, quicktype::ChytridiaceaeClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::ChytridiaceaeClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>>::to_json(json & j, const std::variant<bool, quicktype::ChytridiaceaeClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::ChytridiaceaeClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::DiscordiaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::DiscordiaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::from_json(const json & j, std::variant<int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::to_json(json & j, const std::variant<int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::string>>::from_json(const json & j, std::variant<bool, int64_t, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::string>>::to_json(json & j, const std::variant<bool, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::GryphosaurusClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::GryphosaurusClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>>::from_json(const json & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>>::to_json(json & j, const std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LaviniaClass, std::string>>::from_json(const json & j, std::variant<quicktype::LaviniaClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::LaviniaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LaviniaClass, std::string>>::to_json(json & j, const std::variant<quicktype::LaviniaClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LaviniaClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::OskarClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::OskarClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::OskarClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>>::from_json(const json & j, std::variant<quicktype::Rebecca, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>>::to_json(json & j, const std::variant<quicktype::Rebecca, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>>::from_json(const json & j, std::variant<bool, quicktype::Rebecca, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>>::to_json(json & j, const std::variant<bool, quicktype::Rebecca, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations2.json/const-style-east-const--0048a2a7a881/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations2.json/const-style-east-const--0048a2a7a881/quicktype.hpp
new file mode 100644
index 0000000..6c24a89
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations2.json/const-style-east-const--0048a2a7a881/quicktype.hpp
@@ -0,0 +1,3029 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, std::shared_ptr<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(json const & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, std::optional<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(json const & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(json const & j, char const * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(json const & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    using Abranchiata = std::optional<std::variant<std::vector<int64_t>, int64_t>>;
+
+    using Academe = std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>;
+
+    using Acquirable = std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>;
+
+    using Aerometry = std::variant<bool, double>;
+
+    using Alexin = std::variant<std::vector<int64_t>, bool>;
+
+    class AlleviateClass {
+        public:
+        AlleviateClass() = default;
+        virtual ~AlleviateClass() = default;
+
+        private:
+        nlohmann::json apriori;
+        nlohmann::json beggarer;
+        nlohmann::json brokenheartedly;
+        nlohmann::json debilitation;
+        nlohmann::json frike;
+        nlohmann::json gastrolith;
+        nlohmann::json hulsean;
+        nlohmann::json orthocentric;
+        nlohmann::json petaly;
+        nlohmann::json probudgeting;
+        nlohmann::json reacquire;
+        nlohmann::json scow;
+        nlohmann::json shutoff;
+        nlohmann::json subcontiguous;
+        nlohmann::json suffumigate;
+        nlohmann::json transformable;
+        nlohmann::json uncoroneted;
+        nlohmann::json unparking;
+        nlohmann::json unvarnishedness;
+        nlohmann::json wherewithal;
+
+        public:
+        nlohmann::json const & get_apriori() const { return apriori; }
+        nlohmann::json & get_mutable_apriori() { return apriori; }
+        void set_apriori(nlohmann::json const & value) { this->apriori = value; }
+
+        nlohmann::json const & get_beggarer() const { return beggarer; }
+        nlohmann::json & get_mutable_beggarer() { return beggarer; }
+        void set_beggarer(nlohmann::json const & value) { this->beggarer = value; }
+
+        nlohmann::json const & get_brokenheartedly() const { return brokenheartedly; }
+        nlohmann::json & get_mutable_brokenheartedly() { return brokenheartedly; }
+        void set_brokenheartedly(nlohmann::json const & value) { this->brokenheartedly = value; }
+
+        nlohmann::json const & get_debilitation() const { return debilitation; }
+        nlohmann::json & get_mutable_debilitation() { return debilitation; }
+        void set_debilitation(nlohmann::json const & value) { this->debilitation = value; }
+
+        nlohmann::json const & get_frike() const { return frike; }
+        nlohmann::json & get_mutable_frike() { return frike; }
+        void set_frike(nlohmann::json const & value) { this->frike = value; }
+
+        nlohmann::json const & get_gastrolith() const { return gastrolith; }
+        nlohmann::json & get_mutable_gastrolith() { return gastrolith; }
+        void set_gastrolith(nlohmann::json const & value) { this->gastrolith = value; }
+
+        nlohmann::json const & get_hulsean() const { return hulsean; }
+        nlohmann::json & get_mutable_hulsean() { return hulsean; }
+        void set_hulsean(nlohmann::json const & value) { this->hulsean = value; }
+
+        nlohmann::json const & get_orthocentric() const { return orthocentric; }
+        nlohmann::json & get_mutable_orthocentric() { return orthocentric; }
+        void set_orthocentric(nlohmann::json const & value) { this->orthocentric = value; }
+
+        nlohmann::json const & get_petaly() const { return petaly; }
+        nlohmann::json & get_mutable_petaly() { return petaly; }
+        void set_petaly(nlohmann::json const & value) { this->petaly = value; }
+
+        nlohmann::json const & get_probudgeting() const { return probudgeting; }
+        nlohmann::json & get_mutable_probudgeting() { return probudgeting; }
+        void set_probudgeting(nlohmann::json const & value) { this->probudgeting = value; }
+
+        nlohmann::json const & get_reacquire() const { return reacquire; }
+        nlohmann::json & get_mutable_reacquire() { return reacquire; }
+        void set_reacquire(nlohmann::json const & value) { this->reacquire = value; }
+
+        nlohmann::json const & get_scow() const { return scow; }
+        nlohmann::json & get_mutable_scow() { return scow; }
+        void set_scow(nlohmann::json const & value) { this->scow = value; }
+
+        nlohmann::json const & get_shutoff() const { return shutoff; }
+        nlohmann::json & get_mutable_shutoff() { return shutoff; }
+        void set_shutoff(nlohmann::json const & value) { this->shutoff = value; }
+
+        nlohmann::json const & get_subcontiguous() const { return subcontiguous; }
+        nlohmann::json & get_mutable_subcontiguous() { return subcontiguous; }
+        void set_subcontiguous(nlohmann::json const & value) { this->subcontiguous = value; }
+
+        nlohmann::json const & get_suffumigate() const { return suffumigate; }
+        nlohmann::json & get_mutable_suffumigate() { return suffumigate; }
+        void set_suffumigate(nlohmann::json const & value) { this->suffumigate = value; }
+
+        nlohmann::json const & get_transformable() const { return transformable; }
+        nlohmann::json & get_mutable_transformable() { return transformable; }
+        void set_transformable(nlohmann::json const & value) { this->transformable = value; }
+
+        nlohmann::json const & get_uncoroneted() const { return uncoroneted; }
+        nlohmann::json & get_mutable_uncoroneted() { return uncoroneted; }
+        void set_uncoroneted(nlohmann::json const & value) { this->uncoroneted = value; }
+
+        nlohmann::json const & get_unparking() const { return unparking; }
+        nlohmann::json & get_mutable_unparking() { return unparking; }
+        void set_unparking(nlohmann::json const & value) { this->unparking = value; }
+
+        nlohmann::json const & get_unvarnishedness() const { return unvarnishedness; }
+        nlohmann::json & get_mutable_unvarnishedness() { return unvarnishedness; }
+        void set_unvarnishedness(nlohmann::json const & value) { this->unvarnishedness = value; }
+
+        nlohmann::json const & get_wherewithal() const { return wherewithal; }
+        nlohmann::json & get_mutable_wherewithal() { return wherewithal; }
+        void set_wherewithal(nlohmann::json const & value) { this->wherewithal = value; }
+    };
+
+    using AlleviateElement = std::variant<std::vector<std::optional<int64_t>>, AlleviateClass>;
+
+    class Rebecca {
+        public:
+        Rebecca() = default;
+        virtual ~Rebecca() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        double const & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(double const & value) { this->catharticalness = value; }
+
+        int64_t const & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(int64_t const & value) { this->chirotherium = value; }
+
+        std::string const & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::string const & value) { this->disdiapason = value; }
+
+        bool const & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(bool const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+    };
+
+    using Amaa = std::variant<bool, Rebecca, int64_t>;
+
+    using Ambassage = std::variant<std::vector<nlohmann::json>, std::string>;
+
+    class Amphithyron {
+        public:
+        Amphithyron() = default;
+        virtual ~Amphithyron() = default;
+
+        private:
+        std::optional<int64_t> akroasis;
+        std::optional<int64_t> antiphonical;
+        std::optional<int64_t> basebred;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> conductometric;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ensilation;
+        std::optional<int64_t> eyebolt;
+        std::optional<int64_t> fistulated;
+        std::optional<int64_t> heteropod;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> juniperus;
+        std::optional<int64_t> labyrinthically;
+        std::optional<int64_t> martyrization;
+        std::optional<int64_t> mispolicy;
+        std::optional<int64_t> multipara;
+        std::optional<int64_t> nazirite;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> possessorial;
+        std::optional<int64_t> shamed;
+        std::optional<int64_t> shelfworn;
+        std::optional<int64_t> stagnum;
+        std::optional<int64_t> those;
+        std::optional<int64_t> undecimal;
+
+        public:
+        std::optional<int64_t> const & get_akroasis() const { return akroasis; }
+        std::optional<int64_t> & get_mutable_akroasis() { return akroasis; }
+        void set_akroasis(std::optional<int64_t> const & value) { this->akroasis = value; }
+
+        std::optional<int64_t> const & get_antiphonical() const { return antiphonical; }
+        std::optional<int64_t> & get_mutable_antiphonical() { return antiphonical; }
+        void set_antiphonical(std::optional<int64_t> const & value) { this->antiphonical = value; }
+
+        std::optional<int64_t> const & get_basebred() const { return basebred; }
+        std::optional<int64_t> & get_mutable_basebred() { return basebred; }
+        void set_basebred(std::optional<int64_t> const & value) { this->basebred = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_conductometric() const { return conductometric; }
+        std::optional<int64_t> & get_mutable_conductometric() { return conductometric; }
+        void set_conductometric(std::optional<int64_t> const & value) { this->conductometric = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_ensilation() const { return ensilation; }
+        std::optional<int64_t> & get_mutable_ensilation() { return ensilation; }
+        void set_ensilation(std::optional<int64_t> const & value) { this->ensilation = value; }
+
+        std::optional<int64_t> const & get_eyebolt() const { return eyebolt; }
+        std::optional<int64_t> & get_mutable_eyebolt() { return eyebolt; }
+        void set_eyebolt(std::optional<int64_t> const & value) { this->eyebolt = value; }
+
+        std::optional<int64_t> const & get_fistulated() const { return fistulated; }
+        std::optional<int64_t> & get_mutable_fistulated() { return fistulated; }
+        void set_fistulated(std::optional<int64_t> const & value) { this->fistulated = value; }
+
+        std::optional<int64_t> const & get_heteropod() const { return heteropod; }
+        std::optional<int64_t> & get_mutable_heteropod() { return heteropod; }
+        void set_heteropod(std::optional<int64_t> const & value) { this->heteropod = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_juniperus() const { return juniperus; }
+        std::optional<int64_t> & get_mutable_juniperus() { return juniperus; }
+        void set_juniperus(std::optional<int64_t> const & value) { this->juniperus = value; }
+
+        std::optional<int64_t> const & get_labyrinthically() const { return labyrinthically; }
+        std::optional<int64_t> & get_mutable_labyrinthically() { return labyrinthically; }
+        void set_labyrinthically(std::optional<int64_t> const & value) { this->labyrinthically = value; }
+
+        std::optional<int64_t> const & get_martyrization() const { return martyrization; }
+        std::optional<int64_t> & get_mutable_martyrization() { return martyrization; }
+        void set_martyrization(std::optional<int64_t> const & value) { this->martyrization = value; }
+
+        std::optional<int64_t> const & get_mispolicy() const { return mispolicy; }
+        std::optional<int64_t> & get_mutable_mispolicy() { return mispolicy; }
+        void set_mispolicy(std::optional<int64_t> const & value) { this->mispolicy = value; }
+
+        std::optional<int64_t> const & get_multipara() const { return multipara; }
+        std::optional<int64_t> & get_mutable_multipara() { return multipara; }
+        void set_multipara(std::optional<int64_t> const & value) { this->multipara = value; }
+
+        std::optional<int64_t> const & get_nazirite() const { return nazirite; }
+        std::optional<int64_t> & get_mutable_nazirite() { return nazirite; }
+        void set_nazirite(std::optional<int64_t> const & value) { this->nazirite = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_possessorial() const { return possessorial; }
+        std::optional<int64_t> & get_mutable_possessorial() { return possessorial; }
+        void set_possessorial(std::optional<int64_t> const & value) { this->possessorial = value; }
+
+        std::optional<int64_t> const & get_shamed() const { return shamed; }
+        std::optional<int64_t> & get_mutable_shamed() { return shamed; }
+        void set_shamed(std::optional<int64_t> const & value) { this->shamed = value; }
+
+        std::optional<int64_t> const & get_shelfworn() const { return shelfworn; }
+        std::optional<int64_t> & get_mutable_shelfworn() { return shelfworn; }
+        void set_shelfworn(std::optional<int64_t> const & value) { this->shelfworn = value; }
+
+        std::optional<int64_t> const & get_stagnum() const { return stagnum; }
+        std::optional<int64_t> & get_mutable_stagnum() { return stagnum; }
+        void set_stagnum(std::optional<int64_t> const & value) { this->stagnum = value; }
+
+        std::optional<int64_t> const & get_those() const { return those; }
+        std::optional<int64_t> & get_mutable_those() { return those; }
+        void set_those(std::optional<int64_t> const & value) { this->those = value; }
+
+        std::optional<int64_t> const & get_undecimal() const { return undecimal; }
+        std::optional<int64_t> & get_mutable_undecimal() { return undecimal; }
+        void set_undecimal(std::optional<int64_t> const & value) { this->undecimal = value; }
+    };
+
+    class AnkeeClass {
+        public:
+        AnkeeClass() = default;
+        virtual ~AnkeeClass() = default;
+
+        private:
+        nlohmann::json anomoean;
+        nlohmann::json barleyhood;
+        nlohmann::json befriender;
+        nlohmann::json brutishness;
+        nlohmann::json cephalalgy;
+        nlohmann::json cirurgian;
+        nlohmann::json conventionally;
+        nlohmann::json jackshay;
+        nlohmann::json milammeter;
+        nlohmann::json naja;
+        nlohmann::json ombrological;
+        nlohmann::json phonasthenia;
+        nlohmann::json retrievableness;
+        nlohmann::json snakily;
+        nlohmann::json swot;
+        nlohmann::json tartlet;
+        nlohmann::json thiofuran;
+        nlohmann::json tracheophone;
+        nlohmann::json tuglike;
+        nlohmann::json unscratchingly;
+
+        public:
+        nlohmann::json const & get_anomoean() const { return anomoean; }
+        nlohmann::json & get_mutable_anomoean() { return anomoean; }
+        void set_anomoean(nlohmann::json const & value) { this->anomoean = value; }
+
+        nlohmann::json const & get_barleyhood() const { return barleyhood; }
+        nlohmann::json & get_mutable_barleyhood() { return barleyhood; }
+        void set_barleyhood(nlohmann::json const & value) { this->barleyhood = value; }
+
+        nlohmann::json const & get_befriender() const { return befriender; }
+        nlohmann::json & get_mutable_befriender() { return befriender; }
+        void set_befriender(nlohmann::json const & value) { this->befriender = value; }
+
+        nlohmann::json const & get_brutishness() const { return brutishness; }
+        nlohmann::json & get_mutable_brutishness() { return brutishness; }
+        void set_brutishness(nlohmann::json const & value) { this->brutishness = value; }
+
+        nlohmann::json const & get_cephalalgy() const { return cephalalgy; }
+        nlohmann::json & get_mutable_cephalalgy() { return cephalalgy; }
+        void set_cephalalgy(nlohmann::json const & value) { this->cephalalgy = value; }
+
+        nlohmann::json const & get_cirurgian() const { return cirurgian; }
+        nlohmann::json & get_mutable_cirurgian() { return cirurgian; }
+        void set_cirurgian(nlohmann::json const & value) { this->cirurgian = value; }
+
+        nlohmann::json const & get_conventionally() const { return conventionally; }
+        nlohmann::json & get_mutable_conventionally() { return conventionally; }
+        void set_conventionally(nlohmann::json const & value) { this->conventionally = value; }
+
+        nlohmann::json const & get_jackshay() const { return jackshay; }
+        nlohmann::json & get_mutable_jackshay() { return jackshay; }
+        void set_jackshay(nlohmann::json const & value) { this->jackshay = value; }
+
+        nlohmann::json const & get_milammeter() const { return milammeter; }
+        nlohmann::json & get_mutable_milammeter() { return milammeter; }
+        void set_milammeter(nlohmann::json const & value) { this->milammeter = value; }
+
+        nlohmann::json const & get_naja() const { return naja; }
+        nlohmann::json & get_mutable_naja() { return naja; }
+        void set_naja(nlohmann::json const & value) { this->naja = value; }
+
+        nlohmann::json const & get_ombrological() const { return ombrological; }
+        nlohmann::json & get_mutable_ombrological() { return ombrological; }
+        void set_ombrological(nlohmann::json const & value) { this->ombrological = value; }
+
+        nlohmann::json const & get_phonasthenia() const { return phonasthenia; }
+        nlohmann::json & get_mutable_phonasthenia() { return phonasthenia; }
+        void set_phonasthenia(nlohmann::json const & value) { this->phonasthenia = value; }
+
+        nlohmann::json const & get_retrievableness() const { return retrievableness; }
+        nlohmann::json & get_mutable_retrievableness() { return retrievableness; }
+        void set_retrievableness(nlohmann::json const & value) { this->retrievableness = value; }
+
+        nlohmann::json const & get_snakily() const { return snakily; }
+        nlohmann::json & get_mutable_snakily() { return snakily; }
+        void set_snakily(nlohmann::json const & value) { this->snakily = value; }
+
+        nlohmann::json const & get_swot() const { return swot; }
+        nlohmann::json & get_mutable_swot() { return swot; }
+        void set_swot(nlohmann::json const & value) { this->swot = value; }
+
+        nlohmann::json const & get_tartlet() const { return tartlet; }
+        nlohmann::json & get_mutable_tartlet() { return tartlet; }
+        void set_tartlet(nlohmann::json const & value) { this->tartlet = value; }
+
+        nlohmann::json const & get_thiofuran() const { return thiofuran; }
+        nlohmann::json & get_mutable_thiofuran() { return thiofuran; }
+        void set_thiofuran(nlohmann::json const & value) { this->thiofuran = value; }
+
+        nlohmann::json const & get_tracheophone() const { return tracheophone; }
+        nlohmann::json & get_mutable_tracheophone() { return tracheophone; }
+        void set_tracheophone(nlohmann::json const & value) { this->tracheophone = value; }
+
+        nlohmann::json const & get_tuglike() const { return tuglike; }
+        nlohmann::json & get_mutable_tuglike() { return tuglike; }
+        void set_tuglike(nlohmann::json const & value) { this->tuglike = value; }
+
+        nlohmann::json const & get_unscratchingly() const { return unscratchingly; }
+        nlohmann::json & get_mutable_unscratchingly() { return unscratchingly; }
+        void set_unscratchingly(nlohmann::json const & value) { this->unscratchingly = value; }
+    };
+
+    using AnkeeElement = std::variant<std::vector<int64_t>, AnkeeClass, int64_t>;
+
+    class AnsarieClass {
+        public:
+        AnsarieClass() = default;
+        virtual ~AnsarieClass() = default;
+
+        private:
+        nlohmann::json accension;
+        nlohmann::json alida;
+        nlohmann::json asteria;
+        nlohmann::json beriberic;
+        nlohmann::json edgebone;
+        nlohmann::json gastrodialysis;
+        nlohmann::json geographic;
+        nlohmann::json ictonyx;
+        nlohmann::json metrocele;
+        nlohmann::json misgraft;
+        nlohmann::json monteith;
+        nlohmann::json notcher;
+        nlohmann::json prorestriction;
+        nlohmann::json ramist;
+        nlohmann::json throatlet;
+        nlohmann::json unfair;
+        nlohmann::json unsynonymous;
+        nlohmann::json water;
+        nlohmann::json zestfully;
+        nlohmann::json zincic;
+
+        public:
+        nlohmann::json const & get_accension() const { return accension; }
+        nlohmann::json & get_mutable_accension() { return accension; }
+        void set_accension(nlohmann::json const & value) { this->accension = value; }
+
+        nlohmann::json const & get_alida() const { return alida; }
+        nlohmann::json & get_mutable_alida() { return alida; }
+        void set_alida(nlohmann::json const & value) { this->alida = value; }
+
+        nlohmann::json const & get_asteria() const { return asteria; }
+        nlohmann::json & get_mutable_asteria() { return asteria; }
+        void set_asteria(nlohmann::json const & value) { this->asteria = value; }
+
+        nlohmann::json const & get_beriberic() const { return beriberic; }
+        nlohmann::json & get_mutable_beriberic() { return beriberic; }
+        void set_beriberic(nlohmann::json const & value) { this->beriberic = value; }
+
+        nlohmann::json const & get_edgebone() const { return edgebone; }
+        nlohmann::json & get_mutable_edgebone() { return edgebone; }
+        void set_edgebone(nlohmann::json const & value) { this->edgebone = value; }
+
+        nlohmann::json const & get_gastrodialysis() const { return gastrodialysis; }
+        nlohmann::json & get_mutable_gastrodialysis() { return gastrodialysis; }
+        void set_gastrodialysis(nlohmann::json const & value) { this->gastrodialysis = value; }
+
+        nlohmann::json const & get_geographic() const { return geographic; }
+        nlohmann::json & get_mutable_geographic() { return geographic; }
+        void set_geographic(nlohmann::json const & value) { this->geographic = value; }
+
+        nlohmann::json const & get_ictonyx() const { return ictonyx; }
+        nlohmann::json & get_mutable_ictonyx() { return ictonyx; }
+        void set_ictonyx(nlohmann::json const & value) { this->ictonyx = value; }
+
+        nlohmann::json const & get_metrocele() const { return metrocele; }
+        nlohmann::json & get_mutable_metrocele() { return metrocele; }
+        void set_metrocele(nlohmann::json const & value) { this->metrocele = value; }
+
+        nlohmann::json const & get_misgraft() const { return misgraft; }
+        nlohmann::json & get_mutable_misgraft() { return misgraft; }
+        void set_misgraft(nlohmann::json const & value) { this->misgraft = value; }
+
+        nlohmann::json const & get_monteith() const { return monteith; }
+        nlohmann::json & get_mutable_monteith() { return monteith; }
+        void set_monteith(nlohmann::json const & value) { this->monteith = value; }
+
+        nlohmann::json const & get_notcher() const { return notcher; }
+        nlohmann::json & get_mutable_notcher() { return notcher; }
+        void set_notcher(nlohmann::json const & value) { this->notcher = value; }
+
+        nlohmann::json const & get_prorestriction() const { return prorestriction; }
+        nlohmann::json & get_mutable_prorestriction() { return prorestriction; }
+        void set_prorestriction(nlohmann::json const & value) { this->prorestriction = value; }
+
+        nlohmann::json const & get_ramist() const { return ramist; }
+        nlohmann::json & get_mutable_ramist() { return ramist; }
+        void set_ramist(nlohmann::json const & value) { this->ramist = value; }
+
+        nlohmann::json const & get_throatlet() const { return throatlet; }
+        nlohmann::json & get_mutable_throatlet() { return throatlet; }
+        void set_throatlet(nlohmann::json const & value) { this->throatlet = value; }
+
+        nlohmann::json const & get_unfair() const { return unfair; }
+        nlohmann::json & get_mutable_unfair() { return unfair; }
+        void set_unfair(nlohmann::json const & value) { this->unfair = value; }
+
+        nlohmann::json const & get_unsynonymous() const { return unsynonymous; }
+        nlohmann::json & get_mutable_unsynonymous() { return unsynonymous; }
+        void set_unsynonymous(nlohmann::json const & value) { this->unsynonymous = value; }
+
+        nlohmann::json const & get_water() const { return water; }
+        nlohmann::json & get_mutable_water() { return water; }
+        void set_water(nlohmann::json const & value) { this->water = value; }
+
+        nlohmann::json const & get_zestfully() const { return zestfully; }
+        nlohmann::json & get_mutable_zestfully() { return zestfully; }
+        void set_zestfully(nlohmann::json const & value) { this->zestfully = value; }
+
+        nlohmann::json const & get_zincic() const { return zincic; }
+        nlohmann::json & get_mutable_zincic() { return zincic; }
+        void set_zincic(nlohmann::json const & value) { this->zincic = value; }
+    };
+
+    using AnsarieElement = std::optional<std::variant<std::vector<int64_t>, AnsarieClass>>;
+
+    using Aphasia = std::variant<std::vector<int64_t>, int64_t>;
+
+    using Asprawl = std::variant<double, std::string>;
+
+    using Bedesman = std::variant<bool, double, std::string>;
+
+    using Belard = std::variant<std::vector<int64_t>, Rebecca, double>;
+
+    using Bocking = std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>;
+
+    using Brawlingly = std::variant<std::vector<nlohmann::json>, std::map<std::string, std::optional<int64_t>>>;
+
+    using Brookie = std::variant<std::vector<int64_t>, Rebecca>;
+
+    using Bumboatman = std::optional<std::variant<std::vector<nlohmann::json>, std::string>>;
+
+    using Calaverite = std::variant<std::vector<int64_t>, std::string>;
+
+    using Catallactic = std::variant<std::vector<nlohmann::json>, bool, std::map<std::string, int64_t>>;
+
+    using Cemental = std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>;
+
+    class ChytridiaceaeClass {
+        public:
+        ChytridiaceaeClass() = default;
+        virtual ~ChytridiaceaeClass() = default;
+
+        private:
+        nlohmann::json batidaceae;
+        nlohmann::json brechites;
+        nlohmann::json codespairer;
+        nlohmann::json emery;
+        nlohmann::json enervative;
+        nlohmann::json excriminate;
+        nlohmann::json goshenite;
+        nlohmann::json grime;
+        nlohmann::json gritten;
+        nlohmann::json hectorly;
+        nlohmann::json intermediation;
+        nlohmann::json meeterly;
+        nlohmann::json narraganset;
+        nlohmann::json onymatic;
+        nlohmann::json paddlecock;
+        nlohmann::json thana;
+        nlohmann::json thornily;
+        nlohmann::json uckia;
+        nlohmann::json unmettle;
+        nlohmann::json vorticellid;
+
+        public:
+        nlohmann::json const & get_batidaceae() const { return batidaceae; }
+        nlohmann::json & get_mutable_batidaceae() { return batidaceae; }
+        void set_batidaceae(nlohmann::json const & value) { this->batidaceae = value; }
+
+        nlohmann::json const & get_brechites() const { return brechites; }
+        nlohmann::json & get_mutable_brechites() { return brechites; }
+        void set_brechites(nlohmann::json const & value) { this->brechites = value; }
+
+        nlohmann::json const & get_codespairer() const { return codespairer; }
+        nlohmann::json & get_mutable_codespairer() { return codespairer; }
+        void set_codespairer(nlohmann::json const & value) { this->codespairer = value; }
+
+        nlohmann::json const & get_emery() const { return emery; }
+        nlohmann::json & get_mutable_emery() { return emery; }
+        void set_emery(nlohmann::json const & value) { this->emery = value; }
+
+        nlohmann::json const & get_enervative() const { return enervative; }
+        nlohmann::json & get_mutable_enervative() { return enervative; }
+        void set_enervative(nlohmann::json const & value) { this->enervative = value; }
+
+        nlohmann::json const & get_excriminate() const { return excriminate; }
+        nlohmann::json & get_mutable_excriminate() { return excriminate; }
+        void set_excriminate(nlohmann::json const & value) { this->excriminate = value; }
+
+        nlohmann::json const & get_goshenite() const { return goshenite; }
+        nlohmann::json & get_mutable_goshenite() { return goshenite; }
+        void set_goshenite(nlohmann::json const & value) { this->goshenite = value; }
+
+        nlohmann::json const & get_grime() const { return grime; }
+        nlohmann::json & get_mutable_grime() { return grime; }
+        void set_grime(nlohmann::json const & value) { this->grime = value; }
+
+        nlohmann::json const & get_gritten() const { return gritten; }
+        nlohmann::json & get_mutable_gritten() { return gritten; }
+        void set_gritten(nlohmann::json const & value) { this->gritten = value; }
+
+        nlohmann::json const & get_hectorly() const { return hectorly; }
+        nlohmann::json & get_mutable_hectorly() { return hectorly; }
+        void set_hectorly(nlohmann::json const & value) { this->hectorly = value; }
+
+        nlohmann::json const & get_intermediation() const { return intermediation; }
+        nlohmann::json & get_mutable_intermediation() { return intermediation; }
+        void set_intermediation(nlohmann::json const & value) { this->intermediation = value; }
+
+        nlohmann::json const & get_meeterly() const { return meeterly; }
+        nlohmann::json & get_mutable_meeterly() { return meeterly; }
+        void set_meeterly(nlohmann::json const & value) { this->meeterly = value; }
+
+        nlohmann::json const & get_narraganset() const { return narraganset; }
+        nlohmann::json & get_mutable_narraganset() { return narraganset; }
+        void set_narraganset(nlohmann::json const & value) { this->narraganset = value; }
+
+        nlohmann::json const & get_onymatic() const { return onymatic; }
+        nlohmann::json & get_mutable_onymatic() { return onymatic; }
+        void set_onymatic(nlohmann::json const & value) { this->onymatic = value; }
+
+        nlohmann::json const & get_paddlecock() const { return paddlecock; }
+        nlohmann::json & get_mutable_paddlecock() { return paddlecock; }
+        void set_paddlecock(nlohmann::json const & value) { this->paddlecock = value; }
+
+        nlohmann::json const & get_thana() const { return thana; }
+        nlohmann::json & get_mutable_thana() { return thana; }
+        void set_thana(nlohmann::json const & value) { this->thana = value; }
+
+        nlohmann::json const & get_thornily() const { return thornily; }
+        nlohmann::json & get_mutable_thornily() { return thornily; }
+        void set_thornily(nlohmann::json const & value) { this->thornily = value; }
+
+        nlohmann::json const & get_uckia() const { return uckia; }
+        nlohmann::json & get_mutable_uckia() { return uckia; }
+        void set_uckia(nlohmann::json const & value) { this->uckia = value; }
+
+        nlohmann::json const & get_unmettle() const { return unmettle; }
+        nlohmann::json & get_mutable_unmettle() { return unmettle; }
+        void set_unmettle(nlohmann::json const & value) { this->unmettle = value; }
+
+        nlohmann::json const & get_vorticellid() const { return vorticellid; }
+        nlohmann::json & get_mutable_vorticellid() { return vorticellid; }
+        void set_vorticellid(nlohmann::json const & value) { this->vorticellid = value; }
+    };
+
+    using ChytridiaceaeElement = std::optional<std::variant<bool, ChytridiaceaeClass>>;
+
+    class DiscordiaClass {
+        public:
+        DiscordiaClass() = default;
+        virtual ~DiscordiaClass() = default;
+
+        private:
+        std::optional<int64_t> altaic;
+        std::optional<int64_t> amoristic;
+        std::optional<int64_t> blennophthalmia;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> disciplinability;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> goofer;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> laryngograph;
+        std::optional<int64_t> leucitis;
+        std::optional<int64_t> lymphocyst;
+        std::optional<int64_t> microcosmology;
+        std::optional<int64_t> nauseation;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> patarin;
+        std::optional<int64_t> preliberal;
+        std::optional<int64_t> prettifier;
+        std::optional<int64_t> rangework;
+        std::optional<int64_t> redient;
+        std::optional<int64_t> subfusiform;
+        std::optional<int64_t> suicidical;
+        std::optional<int64_t> swow;
+        std::optional<int64_t> wastrel;
+        std::optional<int64_t> wingle;
+
+        public:
+        std::optional<int64_t> const & get_altaic() const { return altaic; }
+        std::optional<int64_t> & get_mutable_altaic() { return altaic; }
+        void set_altaic(std::optional<int64_t> const & value) { this->altaic = value; }
+
+        std::optional<int64_t> const & get_amoristic() const { return amoristic; }
+        std::optional<int64_t> & get_mutable_amoristic() { return amoristic; }
+        void set_amoristic(std::optional<int64_t> const & value) { this->amoristic = value; }
+
+        std::optional<int64_t> const & get_blennophthalmia() const { return blennophthalmia; }
+        std::optional<int64_t> & get_mutable_blennophthalmia() { return blennophthalmia; }
+        void set_blennophthalmia(std::optional<int64_t> const & value) { this->blennophthalmia = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_disciplinability() const { return disciplinability; }
+        std::optional<int64_t> & get_mutable_disciplinability() { return disciplinability; }
+        void set_disciplinability(std::optional<int64_t> const & value) { this->disciplinability = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_goofer() const { return goofer; }
+        std::optional<int64_t> & get_mutable_goofer() { return goofer; }
+        void set_goofer(std::optional<int64_t> const & value) { this->goofer = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_laryngograph() const { return laryngograph; }
+        std::optional<int64_t> & get_mutable_laryngograph() { return laryngograph; }
+        void set_laryngograph(std::optional<int64_t> const & value) { this->laryngograph = value; }
+
+        std::optional<int64_t> const & get_leucitis() const { return leucitis; }
+        std::optional<int64_t> & get_mutable_leucitis() { return leucitis; }
+        void set_leucitis(std::optional<int64_t> const & value) { this->leucitis = value; }
+
+        std::optional<int64_t> const & get_lymphocyst() const { return lymphocyst; }
+        std::optional<int64_t> & get_mutable_lymphocyst() { return lymphocyst; }
+        void set_lymphocyst(std::optional<int64_t> const & value) { this->lymphocyst = value; }
+
+        std::optional<int64_t> const & get_microcosmology() const { return microcosmology; }
+        std::optional<int64_t> & get_mutable_microcosmology() { return microcosmology; }
+        void set_microcosmology(std::optional<int64_t> const & value) { this->microcosmology = value; }
+
+        std::optional<int64_t> const & get_nauseation() const { return nauseation; }
+        std::optional<int64_t> & get_mutable_nauseation() { return nauseation; }
+        void set_nauseation(std::optional<int64_t> const & value) { this->nauseation = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_patarin() const { return patarin; }
+        std::optional<int64_t> & get_mutable_patarin() { return patarin; }
+        void set_patarin(std::optional<int64_t> const & value) { this->patarin = value; }
+
+        std::optional<int64_t> const & get_preliberal() const { return preliberal; }
+        std::optional<int64_t> & get_mutable_preliberal() { return preliberal; }
+        void set_preliberal(std::optional<int64_t> const & value) { this->preliberal = value; }
+
+        std::optional<int64_t> const & get_prettifier() const { return prettifier; }
+        std::optional<int64_t> & get_mutable_prettifier() { return prettifier; }
+        void set_prettifier(std::optional<int64_t> const & value) { this->prettifier = value; }
+
+        std::optional<int64_t> const & get_rangework() const { return rangework; }
+        std::optional<int64_t> & get_mutable_rangework() { return rangework; }
+        void set_rangework(std::optional<int64_t> const & value) { this->rangework = value; }
+
+        std::optional<int64_t> const & get_redient() const { return redient; }
+        std::optional<int64_t> & get_mutable_redient() { return redient; }
+        void set_redient(std::optional<int64_t> const & value) { this->redient = value; }
+
+        std::optional<int64_t> const & get_subfusiform() const { return subfusiform; }
+        std::optional<int64_t> & get_mutable_subfusiform() { return subfusiform; }
+        void set_subfusiform(std::optional<int64_t> const & value) { this->subfusiform = value; }
+
+        std::optional<int64_t> const & get_suicidical() const { return suicidical; }
+        std::optional<int64_t> & get_mutable_suicidical() { return suicidical; }
+        void set_suicidical(std::optional<int64_t> const & value) { this->suicidical = value; }
+
+        std::optional<int64_t> const & get_swow() const { return swow; }
+        std::optional<int64_t> & get_mutable_swow() { return swow; }
+        void set_swow(std::optional<int64_t> const & value) { this->swow = value; }
+
+        std::optional<int64_t> const & get_wastrel() const { return wastrel; }
+        std::optional<int64_t> & get_mutable_wastrel() { return wastrel; }
+        void set_wastrel(std::optional<int64_t> const & value) { this->wastrel = value; }
+
+        std::optional<int64_t> const & get_wingle() const { return wingle; }
+        std::optional<int64_t> & get_mutable_wingle() { return wingle; }
+        void set_wingle(std::optional<int64_t> const & value) { this->wingle = value; }
+    };
+
+    using DiscordiaElement = std::variant<std::vector<int64_t>, DiscordiaClass>;
+
+    using Endomyce = std::variant<int64_t, std::string>;
+
+    using Epinephelidae = std::variant<bool, int64_t, std::string>;
+
+    using Eupatorium = std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>>;
+
+    class GryphosaurusClass {
+        public:
+        GryphosaurusClass() = default;
+        virtual ~GryphosaurusClass() = default;
+
+        private:
+        nlohmann::json amissibility;
+        nlohmann::json burushaski;
+        nlohmann::json citronin;
+        nlohmann::json coplaintiff;
+        nlohmann::json disquisitionary;
+        nlohmann::json enoplan;
+        nlohmann::json faintness;
+        nlohmann::json hebetomy;
+        nlohmann::json islandry;
+        nlohmann::json lameduck;
+        nlohmann::json overbattle;
+        nlohmann::json overinterested;
+        nlohmann::json phrenologic;
+        nlohmann::json rainband;
+        nlohmann::json shiningly;
+        nlohmann::json stamineous;
+        nlohmann::json subscapularis;
+        nlohmann::json tahami;
+        nlohmann::json undaubed;
+        nlohmann::json underntime;
+
+        public:
+        nlohmann::json const & get_amissibility() const { return amissibility; }
+        nlohmann::json & get_mutable_amissibility() { return amissibility; }
+        void set_amissibility(nlohmann::json const & value) { this->amissibility = value; }
+
+        nlohmann::json const & get_burushaski() const { return burushaski; }
+        nlohmann::json & get_mutable_burushaski() { return burushaski; }
+        void set_burushaski(nlohmann::json const & value) { this->burushaski = value; }
+
+        nlohmann::json const & get_citronin() const { return citronin; }
+        nlohmann::json & get_mutable_citronin() { return citronin; }
+        void set_citronin(nlohmann::json const & value) { this->citronin = value; }
+
+        nlohmann::json const & get_coplaintiff() const { return coplaintiff; }
+        nlohmann::json & get_mutable_coplaintiff() { return coplaintiff; }
+        void set_coplaintiff(nlohmann::json const & value) { this->coplaintiff = value; }
+
+        nlohmann::json const & get_disquisitionary() const { return disquisitionary; }
+        nlohmann::json & get_mutable_disquisitionary() { return disquisitionary; }
+        void set_disquisitionary(nlohmann::json const & value) { this->disquisitionary = value; }
+
+        nlohmann::json const & get_enoplan() const { return enoplan; }
+        nlohmann::json & get_mutable_enoplan() { return enoplan; }
+        void set_enoplan(nlohmann::json const & value) { this->enoplan = value; }
+
+        nlohmann::json const & get_faintness() const { return faintness; }
+        nlohmann::json & get_mutable_faintness() { return faintness; }
+        void set_faintness(nlohmann::json const & value) { this->faintness = value; }
+
+        nlohmann::json const & get_hebetomy() const { return hebetomy; }
+        nlohmann::json & get_mutable_hebetomy() { return hebetomy; }
+        void set_hebetomy(nlohmann::json const & value) { this->hebetomy = value; }
+
+        nlohmann::json const & get_islandry() const { return islandry; }
+        nlohmann::json & get_mutable_islandry() { return islandry; }
+        void set_islandry(nlohmann::json const & value) { this->islandry = value; }
+
+        nlohmann::json const & get_lameduck() const { return lameduck; }
+        nlohmann::json & get_mutable_lameduck() { return lameduck; }
+        void set_lameduck(nlohmann::json const & value) { this->lameduck = value; }
+
+        nlohmann::json const & get_overbattle() const { return overbattle; }
+        nlohmann::json & get_mutable_overbattle() { return overbattle; }
+        void set_overbattle(nlohmann::json const & value) { this->overbattle = value; }
+
+        nlohmann::json const & get_overinterested() const { return overinterested; }
+        nlohmann::json & get_mutable_overinterested() { return overinterested; }
+        void set_overinterested(nlohmann::json const & value) { this->overinterested = value; }
+
+        nlohmann::json const & get_phrenologic() const { return phrenologic; }
+        nlohmann::json & get_mutable_phrenologic() { return phrenologic; }
+        void set_phrenologic(nlohmann::json const & value) { this->phrenologic = value; }
+
+        nlohmann::json const & get_rainband() const { return rainband; }
+        nlohmann::json & get_mutable_rainband() { return rainband; }
+        void set_rainband(nlohmann::json const & value) { this->rainband = value; }
+
+        nlohmann::json const & get_shiningly() const { return shiningly; }
+        nlohmann::json & get_mutable_shiningly() { return shiningly; }
+        void set_shiningly(nlohmann::json const & value) { this->shiningly = value; }
+
+        nlohmann::json const & get_stamineous() const { return stamineous; }
+        nlohmann::json & get_mutable_stamineous() { return stamineous; }
+        void set_stamineous(nlohmann::json const & value) { this->stamineous = value; }
+
+        nlohmann::json const & get_subscapularis() const { return subscapularis; }
+        nlohmann::json & get_mutable_subscapularis() { return subscapularis; }
+        void set_subscapularis(nlohmann::json const & value) { this->subscapularis = value; }
+
+        nlohmann::json const & get_tahami() const { return tahami; }
+        nlohmann::json & get_mutable_tahami() { return tahami; }
+        void set_tahami(nlohmann::json const & value) { this->tahami = value; }
+
+        nlohmann::json const & get_undaubed() const { return undaubed; }
+        nlohmann::json & get_mutable_undaubed() { return undaubed; }
+        void set_undaubed(nlohmann::json const & value) { this->undaubed = value; }
+
+        nlohmann::json const & get_underntime() const { return underntime; }
+        nlohmann::json & get_mutable_underntime() { return underntime; }
+        void set_underntime(nlohmann::json const & value) { this->underntime = value; }
+    };
+
+    using GryphosaurusElement = std::variant<std::vector<int64_t>, GryphosaurusClass, std::string>;
+
+    using Koryak = std::variant<std::map<std::string, std::optional<int64_t>>, std::string>;
+
+    class LaviniaClass {
+        public:
+        LaviniaClass() = default;
+        virtual ~LaviniaClass() = default;
+
+        private:
+        std::optional<int64_t> agitable;
+        std::optional<int64_t> asininity;
+        std::optional<int64_t> benefiter;
+        std::optional<int64_t> bronzelike;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> cholesteatomatous;
+        std::optional<int64_t> deprivement;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> flippantness;
+        std::optional<int64_t> fogproof;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> merrymeeting;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> overcareful;
+        std::optional<int64_t> panaris;
+        std::optional<int64_t> preacceptance;
+        std::optional<int64_t> quinoxaline;
+        std::optional<int64_t> sig;
+        std::optional<int64_t> superconfusion;
+        std::optional<int64_t> tacana;
+        std::optional<int64_t> tillotter;
+        std::optional<int64_t> tranquillize;
+        std::optional<int64_t> unquestionable;
+        std::optional<int64_t> uproute;
+
+        public:
+        std::optional<int64_t> const & get_agitable() const { return agitable; }
+        std::optional<int64_t> & get_mutable_agitable() { return agitable; }
+        void set_agitable(std::optional<int64_t> const & value) { this->agitable = value; }
+
+        std::optional<int64_t> const & get_asininity() const { return asininity; }
+        std::optional<int64_t> & get_mutable_asininity() { return asininity; }
+        void set_asininity(std::optional<int64_t> const & value) { this->asininity = value; }
+
+        std::optional<int64_t> const & get_benefiter() const { return benefiter; }
+        std::optional<int64_t> & get_mutable_benefiter() { return benefiter; }
+        void set_benefiter(std::optional<int64_t> const & value) { this->benefiter = value; }
+
+        std::optional<int64_t> const & get_bronzelike() const { return bronzelike; }
+        std::optional<int64_t> & get_mutable_bronzelike() { return bronzelike; }
+        void set_bronzelike(std::optional<int64_t> const & value) { this->bronzelike = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_cholesteatomatous() const { return cholesteatomatous; }
+        std::optional<int64_t> & get_mutable_cholesteatomatous() { return cholesteatomatous; }
+        void set_cholesteatomatous(std::optional<int64_t> const & value) { this->cholesteatomatous = value; }
+
+        std::optional<int64_t> const & get_deprivement() const { return deprivement; }
+        std::optional<int64_t> & get_mutable_deprivement() { return deprivement; }
+        void set_deprivement(std::optional<int64_t> const & value) { this->deprivement = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_flippantness() const { return flippantness; }
+        std::optional<int64_t> & get_mutable_flippantness() { return flippantness; }
+        void set_flippantness(std::optional<int64_t> const & value) { this->flippantness = value; }
+
+        std::optional<int64_t> const & get_fogproof() const { return fogproof; }
+        std::optional<int64_t> & get_mutable_fogproof() { return fogproof; }
+        void set_fogproof(std::optional<int64_t> const & value) { this->fogproof = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_merrymeeting() const { return merrymeeting; }
+        std::optional<int64_t> & get_mutable_merrymeeting() { return merrymeeting; }
+        void set_merrymeeting(std::optional<int64_t> const & value) { this->merrymeeting = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_overcareful() const { return overcareful; }
+        std::optional<int64_t> & get_mutable_overcareful() { return overcareful; }
+        void set_overcareful(std::optional<int64_t> const & value) { this->overcareful = value; }
+
+        std::optional<int64_t> const & get_panaris() const { return panaris; }
+        std::optional<int64_t> & get_mutable_panaris() { return panaris; }
+        void set_panaris(std::optional<int64_t> const & value) { this->panaris = value; }
+
+        std::optional<int64_t> const & get_preacceptance() const { return preacceptance; }
+        std::optional<int64_t> & get_mutable_preacceptance() { return preacceptance; }
+        void set_preacceptance(std::optional<int64_t> const & value) { this->preacceptance = value; }
+
+        std::optional<int64_t> const & get_quinoxaline() const { return quinoxaline; }
+        std::optional<int64_t> & get_mutable_quinoxaline() { return quinoxaline; }
+        void set_quinoxaline(std::optional<int64_t> const & value) { this->quinoxaline = value; }
+
+        std::optional<int64_t> const & get_sig() const { return sig; }
+        std::optional<int64_t> & get_mutable_sig() { return sig; }
+        void set_sig(std::optional<int64_t> const & value) { this->sig = value; }
+
+        std::optional<int64_t> const & get_superconfusion() const { return superconfusion; }
+        std::optional<int64_t> & get_mutable_superconfusion() { return superconfusion; }
+        void set_superconfusion(std::optional<int64_t> const & value) { this->superconfusion = value; }
+
+        std::optional<int64_t> const & get_tacana() const { return tacana; }
+        std::optional<int64_t> & get_mutable_tacana() { return tacana; }
+        void set_tacana(std::optional<int64_t> const & value) { this->tacana = value; }
+
+        std::optional<int64_t> const & get_tillotter() const { return tillotter; }
+        std::optional<int64_t> & get_mutable_tillotter() { return tillotter; }
+        void set_tillotter(std::optional<int64_t> const & value) { this->tillotter = value; }
+
+        std::optional<int64_t> const & get_tranquillize() const { return tranquillize; }
+        std::optional<int64_t> & get_mutable_tranquillize() { return tranquillize; }
+        void set_tranquillize(std::optional<int64_t> const & value) { this->tranquillize = value; }
+
+        std::optional<int64_t> const & get_unquestionable() const { return unquestionable; }
+        std::optional<int64_t> & get_mutable_unquestionable() { return unquestionable; }
+        void set_unquestionable(std::optional<int64_t> const & value) { this->unquestionable = value; }
+
+        std::optional<int64_t> const & get_uproute() const { return uproute; }
+        std::optional<int64_t> & get_mutable_uproute() { return uproute; }
+        void set_uproute(std::optional<int64_t> const & value) { this->uproute = value; }
+    };
+
+    using LaviniaElement = std::variant<LaviniaClass, std::string>;
+
+    class OskarClass {
+        public:
+        OskarClass() = default;
+        virtual ~OskarClass() = default;
+
+        private:
+        nlohmann::json acrobates;
+        nlohmann::json beanshooter;
+        nlohmann::json bearhound;
+        nlohmann::json cayuga;
+        nlohmann::json guarneri;
+        nlohmann::json hypochondriacism;
+        nlohmann::json indication;
+        nlohmann::json jaculative;
+        nlohmann::json nagana;
+        nlohmann::json netherlandish;
+        nlohmann::json noctivagous;
+        nlohmann::json nonphysiological;
+        nlohmann::json praxis;
+        nlohmann::json provision;
+        nlohmann::json subterhuman;
+        nlohmann::json sunlit;
+        nlohmann::json syncraniate;
+        nlohmann::json teachment;
+        nlohmann::json unmutinous;
+        nlohmann::json unstoppable;
+
+        public:
+        nlohmann::json const & get_acrobates() const { return acrobates; }
+        nlohmann::json & get_mutable_acrobates() { return acrobates; }
+        void set_acrobates(nlohmann::json const & value) { this->acrobates = value; }
+
+        nlohmann::json const & get_beanshooter() const { return beanshooter; }
+        nlohmann::json & get_mutable_beanshooter() { return beanshooter; }
+        void set_beanshooter(nlohmann::json const & value) { this->beanshooter = value; }
+
+        nlohmann::json const & get_bearhound() const { return bearhound; }
+        nlohmann::json & get_mutable_bearhound() { return bearhound; }
+        void set_bearhound(nlohmann::json const & value) { this->bearhound = value; }
+
+        nlohmann::json const & get_cayuga() const { return cayuga; }
+        nlohmann::json & get_mutable_cayuga() { return cayuga; }
+        void set_cayuga(nlohmann::json const & value) { this->cayuga = value; }
+
+        nlohmann::json const & get_guarneri() const { return guarneri; }
+        nlohmann::json & get_mutable_guarneri() { return guarneri; }
+        void set_guarneri(nlohmann::json const & value) { this->guarneri = value; }
+
+        nlohmann::json const & get_hypochondriacism() const { return hypochondriacism; }
+        nlohmann::json & get_mutable_hypochondriacism() { return hypochondriacism; }
+        void set_hypochondriacism(nlohmann::json const & value) { this->hypochondriacism = value; }
+
+        nlohmann::json const & get_indication() const { return indication; }
+        nlohmann::json & get_mutable_indication() { return indication; }
+        void set_indication(nlohmann::json const & value) { this->indication = value; }
+
+        nlohmann::json const & get_jaculative() const { return jaculative; }
+        nlohmann::json & get_mutable_jaculative() { return jaculative; }
+        void set_jaculative(nlohmann::json const & value) { this->jaculative = value; }
+
+        nlohmann::json const & get_nagana() const { return nagana; }
+        nlohmann::json & get_mutable_nagana() { return nagana; }
+        void set_nagana(nlohmann::json const & value) { this->nagana = value; }
+
+        nlohmann::json const & get_netherlandish() const { return netherlandish; }
+        nlohmann::json & get_mutable_netherlandish() { return netherlandish; }
+        void set_netherlandish(nlohmann::json const & value) { this->netherlandish = value; }
+
+        nlohmann::json const & get_noctivagous() const { return noctivagous; }
+        nlohmann::json & get_mutable_noctivagous() { return noctivagous; }
+        void set_noctivagous(nlohmann::json const & value) { this->noctivagous = value; }
+
+        nlohmann::json const & get_nonphysiological() const { return nonphysiological; }
+        nlohmann::json & get_mutable_nonphysiological() { return nonphysiological; }
+        void set_nonphysiological(nlohmann::json const & value) { this->nonphysiological = value; }
+
+        nlohmann::json const & get_praxis() const { return praxis; }
+        nlohmann::json & get_mutable_praxis() { return praxis; }
+        void set_praxis(nlohmann::json const & value) { this->praxis = value; }
+
+        nlohmann::json const & get_provision() const { return provision; }
+        nlohmann::json & get_mutable_provision() { return provision; }
+        void set_provision(nlohmann::json const & value) { this->provision = value; }
+
+        nlohmann::json const & get_subterhuman() const { return subterhuman; }
+        nlohmann::json & get_mutable_subterhuman() { return subterhuman; }
+        void set_subterhuman(nlohmann::json const & value) { this->subterhuman = value; }
+
+        nlohmann::json const & get_sunlit() const { return sunlit; }
+        nlohmann::json & get_mutable_sunlit() { return sunlit; }
+        void set_sunlit(nlohmann::json const & value) { this->sunlit = value; }
+
+        nlohmann::json const & get_syncraniate() const { return syncraniate; }
+        nlohmann::json & get_mutable_syncraniate() { return syncraniate; }
+        void set_syncraniate(nlohmann::json const & value) { this->syncraniate = value; }
+
+        nlohmann::json const & get_teachment() const { return teachment; }
+        nlohmann::json & get_mutable_teachment() { return teachment; }
+        void set_teachment(nlohmann::json const & value) { this->teachment = value; }
+
+        nlohmann::json const & get_unmutinous() const { return unmutinous; }
+        nlohmann::json & get_mutable_unmutinous() { return unmutinous; }
+        void set_unmutinous(nlohmann::json const & value) { this->unmutinous = value; }
+
+        nlohmann::json const & get_unstoppable() const { return unstoppable; }
+        nlohmann::json & get_mutable_unstoppable() { return unstoppable; }
+        void set_unstoppable(nlohmann::json const & value) { this->unstoppable = value; }
+    };
+
+    using OskarElement = std::variant<std::vector<int64_t>, OskarClass>;
+
+    using RebeccaElement = std::variant<Rebecca, int64_t, std::string>;
+
+    using Rhomboganoidei = std::variant<std::vector<int64_t>, Rebecca, std::string>;
+
+    using Ruellia = std::variant<bool, Rebecca, std::string>;
+
+    using School = std::optional<std::variant<int64_t, std::map<std::string, int64_t>>>;
+
+    using Shakespearolater = std::variant<std::vector<int64_t>, double, std::string>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::vector<Abranchiata> abranchiata;
+        std::vector<Academe> academe;
+        std::vector<Acquirable> acquirable;
+        std::vector<Aerometry> aerometry;
+        std::vector<Alexin> alexin;
+        std::vector<AlleviateElement> alleviate;
+        std::vector<Amaa> amaas;
+        std::vector<Ambassage> ambassage;
+        std::vector<std::optional<Amphithyron>> amphithyron;
+        std::vector<std::optional<std::string>> andriana;
+        std::vector<AnkeeElement> ankee;
+        std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> annihilator;
+        nlohmann::json annulose;
+        std::vector<AnsarieElement> ansarie;
+        std::vector<Aphasia> aphasia;
+        std::vector<Asprawl> asprawl;
+        std::vector<std::optional<bool>> attractive;
+        std::map<std::string, int64_t> barksome;
+        std::vector<Bedesman> bedesman;
+        std::vector<Belard> belard;
+        std::vector<Bocking> bocking;
+        std::vector<Brawlingly> brawlingly;
+        std::vector<Brookie> brookie;
+        std::vector<Bumboatman> bumboatman;
+        std::vector<nlohmann::json> bystreet;
+        std::vector<Calaverite> calaverite;
+        std::vector<Catallactic> catallactic;
+        std::vector<Cemental> cemental;
+        std::vector<ChytridiaceaeElement> chytridiaceae;
+        std::vector<DiscordiaElement> discordia;
+        std::vector<Endomyce> endomyces;
+        std::vector<Epinephelidae> epinephelidae;
+        std::vector<Eupatorium> eupatorium;
+        std::vector<GryphosaurusElement> gryphosaurus;
+        std::vector<Koryak> koryak;
+        std::vector<LaviniaElement> lavinia;
+        std::vector<OskarElement> oskar;
+        std::vector<RebeccaElement> rebecca;
+        std::vector<Rhomboganoidei> rhomboganoidei;
+        bool rigsmal;
+        std::vector<Ruellia> ruellia;
+        std::vector<School> school;
+        std::vector<Shakespearolater> shakespearolater;
+        std::vector<double> svan;
+        std::map<std::string, double> wayao;
+
+        public:
+        std::vector<Abranchiata> const & get_abranchiata() const { return abranchiata; }
+        std::vector<Abranchiata> & get_mutable_abranchiata() { return abranchiata; }
+        void set_abranchiata(std::vector<Abranchiata> const & value) { this->abranchiata = value; }
+
+        std::vector<Academe> const & get_academe() const { return academe; }
+        std::vector<Academe> & get_mutable_academe() { return academe; }
+        void set_academe(std::vector<Academe> const & value) { this->academe = value; }
+
+        std::vector<Acquirable> const & get_acquirable() const { return acquirable; }
+        std::vector<Acquirable> & get_mutable_acquirable() { return acquirable; }
+        void set_acquirable(std::vector<Acquirable> const & value) { this->acquirable = value; }
+
+        std::vector<Aerometry> const & get_aerometry() const { return aerometry; }
+        std::vector<Aerometry> & get_mutable_aerometry() { return aerometry; }
+        void set_aerometry(std::vector<Aerometry> const & value) { this->aerometry = value; }
+
+        std::vector<Alexin> const & get_alexin() const { return alexin; }
+        std::vector<Alexin> & get_mutable_alexin() { return alexin; }
+        void set_alexin(std::vector<Alexin> const & value) { this->alexin = value; }
+
+        std::vector<AlleviateElement> const & get_alleviate() const { return alleviate; }
+        std::vector<AlleviateElement> & get_mutable_alleviate() { return alleviate; }
+        void set_alleviate(std::vector<AlleviateElement> const & value) { this->alleviate = value; }
+
+        std::vector<Amaa> const & get_amaas() const { return amaas; }
+        std::vector<Amaa> & get_mutable_amaas() { return amaas; }
+        void set_amaas(std::vector<Amaa> const & value) { this->amaas = value; }
+
+        std::vector<Ambassage> const & get_ambassage() const { return ambassage; }
+        std::vector<Ambassage> & get_mutable_ambassage() { return ambassage; }
+        void set_ambassage(std::vector<Ambassage> const & value) { this->ambassage = value; }
+
+        std::vector<std::optional<Amphithyron>> const & get_amphithyron() const { return amphithyron; }
+        std::vector<std::optional<Amphithyron>> & get_mutable_amphithyron() { return amphithyron; }
+        void set_amphithyron(std::vector<std::optional<Amphithyron>> const & value) { this->amphithyron = value; }
+
+        std::vector<std::optional<std::string>> const & get_andriana() const { return andriana; }
+        std::vector<std::optional<std::string>> & get_mutable_andriana() { return andriana; }
+        void set_andriana(std::vector<std::optional<std::string>> const & value) { this->andriana = value; }
+
+        std::vector<AnkeeElement> const & get_ankee() const { return ankee; }
+        std::vector<AnkeeElement> & get_mutable_ankee() { return ankee; }
+        void set_ankee(std::vector<AnkeeElement> const & value) { this->ankee = value; }
+
+        std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> const & get_annihilator() const { return annihilator; }
+        std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> & get_mutable_annihilator() { return annihilator; }
+        void set_annihilator(std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> const & value) { this->annihilator = value; }
+
+        nlohmann::json const & get_annulose() const { return annulose; }
+        nlohmann::json & get_mutable_annulose() { return annulose; }
+        void set_annulose(nlohmann::json const & value) { this->annulose = value; }
+
+        std::vector<AnsarieElement> const & get_ansarie() const { return ansarie; }
+        std::vector<AnsarieElement> & get_mutable_ansarie() { return ansarie; }
+        void set_ansarie(std::vector<AnsarieElement> const & value) { this->ansarie = value; }
+
+        std::vector<Aphasia> const & get_aphasia() const { return aphasia; }
+        std::vector<Aphasia> & get_mutable_aphasia() { return aphasia; }
+        void set_aphasia(std::vector<Aphasia> const & value) { this->aphasia = value; }
+
+        std::vector<Asprawl> const & get_asprawl() const { return asprawl; }
+        std::vector<Asprawl> & get_mutable_asprawl() { return asprawl; }
+        void set_asprawl(std::vector<Asprawl> const & value) { this->asprawl = value; }
+
+        std::vector<std::optional<bool>> const & get_attractive() const { return attractive; }
+        std::vector<std::optional<bool>> & get_mutable_attractive() { return attractive; }
+        void set_attractive(std::vector<std::optional<bool>> const & value) { this->attractive = value; }
+
+        std::map<std::string, int64_t> const & get_barksome() const { return barksome; }
+        std::map<std::string, int64_t> & get_mutable_barksome() { return barksome; }
+        void set_barksome(std::map<std::string, int64_t> const & value) { this->barksome = value; }
+
+        std::vector<Bedesman> const & get_bedesman() const { return bedesman; }
+        std::vector<Bedesman> & get_mutable_bedesman() { return bedesman; }
+        void set_bedesman(std::vector<Bedesman> const & value) { this->bedesman = value; }
+
+        std::vector<Belard> const & get_belard() const { return belard; }
+        std::vector<Belard> & get_mutable_belard() { return belard; }
+        void set_belard(std::vector<Belard> const & value) { this->belard = value; }
+
+        std::vector<Bocking> const & get_bocking() const { return bocking; }
+        std::vector<Bocking> & get_mutable_bocking() { return bocking; }
+        void set_bocking(std::vector<Bocking> const & value) { this->bocking = value; }
+
+        std::vector<Brawlingly> const & get_brawlingly() const { return brawlingly; }
+        std::vector<Brawlingly> & get_mutable_brawlingly() { return brawlingly; }
+        void set_brawlingly(std::vector<Brawlingly> const & value) { this->brawlingly = value; }
+
+        std::vector<Brookie> const & get_brookie() const { return brookie; }
+        std::vector<Brookie> & get_mutable_brookie() { return brookie; }
+        void set_brookie(std::vector<Brookie> const & value) { this->brookie = value; }
+
+        std::vector<Bumboatman> const & get_bumboatman() const { return bumboatman; }
+        std::vector<Bumboatman> & get_mutable_bumboatman() { return bumboatman; }
+        void set_bumboatman(std::vector<Bumboatman> const & value) { this->bumboatman = value; }
+
+        std::vector<nlohmann::json> const & get_bystreet() const { return bystreet; }
+        std::vector<nlohmann::json> & get_mutable_bystreet() { return bystreet; }
+        void set_bystreet(std::vector<nlohmann::json> const & value) { this->bystreet = value; }
+
+        std::vector<Calaverite> const & get_calaverite() const { return calaverite; }
+        std::vector<Calaverite> & get_mutable_calaverite() { return calaverite; }
+        void set_calaverite(std::vector<Calaverite> const & value) { this->calaverite = value; }
+
+        std::vector<Catallactic> const & get_catallactic() const { return catallactic; }
+        std::vector<Catallactic> & get_mutable_catallactic() { return catallactic; }
+        void set_catallactic(std::vector<Catallactic> const & value) { this->catallactic = value; }
+
+        std::vector<Cemental> const & get_cemental() const { return cemental; }
+        std::vector<Cemental> & get_mutable_cemental() { return cemental; }
+        void set_cemental(std::vector<Cemental> const & value) { this->cemental = value; }
+
+        std::vector<ChytridiaceaeElement> const & get_chytridiaceae() const { return chytridiaceae; }
+        std::vector<ChytridiaceaeElement> & get_mutable_chytridiaceae() { return chytridiaceae; }
+        void set_chytridiaceae(std::vector<ChytridiaceaeElement> const & value) { this->chytridiaceae = value; }
+
+        std::vector<DiscordiaElement> const & get_discordia() const { return discordia; }
+        std::vector<DiscordiaElement> & get_mutable_discordia() { return discordia; }
+        void set_discordia(std::vector<DiscordiaElement> const & value) { this->discordia = value; }
+
+        std::vector<Endomyce> const & get_endomyces() const { return endomyces; }
+        std::vector<Endomyce> & get_mutable_endomyces() { return endomyces; }
+        void set_endomyces(std::vector<Endomyce> const & value) { this->endomyces = value; }
+
+        std::vector<Epinephelidae> const & get_epinephelidae() const { return epinephelidae; }
+        std::vector<Epinephelidae> & get_mutable_epinephelidae() { return epinephelidae; }
+        void set_epinephelidae(std::vector<Epinephelidae> const & value) { this->epinephelidae = value; }
+
+        std::vector<Eupatorium> const & get_eupatorium() const { return eupatorium; }
+        std::vector<Eupatorium> & get_mutable_eupatorium() { return eupatorium; }
+        void set_eupatorium(std::vector<Eupatorium> const & value) { this->eupatorium = value; }
+
+        std::vector<GryphosaurusElement> const & get_gryphosaurus() const { return gryphosaurus; }
+        std::vector<GryphosaurusElement> & get_mutable_gryphosaurus() { return gryphosaurus; }
+        void set_gryphosaurus(std::vector<GryphosaurusElement> const & value) { this->gryphosaurus = value; }
+
+        std::vector<Koryak> const & get_koryak() const { return koryak; }
+        std::vector<Koryak> & get_mutable_koryak() { return koryak; }
+        void set_koryak(std::vector<Koryak> const & value) { this->koryak = value; }
+
+        std::vector<LaviniaElement> const & get_lavinia() const { return lavinia; }
+        std::vector<LaviniaElement> & get_mutable_lavinia() { return lavinia; }
+        void set_lavinia(std::vector<LaviniaElement> const & value) { this->lavinia = value; }
+
+        std::vector<OskarElement> const & get_oskar() const { return oskar; }
+        std::vector<OskarElement> & get_mutable_oskar() { return oskar; }
+        void set_oskar(std::vector<OskarElement> const & value) { this->oskar = value; }
+
+        std::vector<RebeccaElement> const & get_rebecca() const { return rebecca; }
+        std::vector<RebeccaElement> & get_mutable_rebecca() { return rebecca; }
+        void set_rebecca(std::vector<RebeccaElement> const & value) { this->rebecca = value; }
+
+        std::vector<Rhomboganoidei> const & get_rhomboganoidei() const { return rhomboganoidei; }
+        std::vector<Rhomboganoidei> & get_mutable_rhomboganoidei() { return rhomboganoidei; }
+        void set_rhomboganoidei(std::vector<Rhomboganoidei> const & value) { this->rhomboganoidei = value; }
+
+        bool const & get_rigsmal() const { return rigsmal; }
+        bool & get_mutable_rigsmal() { return rigsmal; }
+        void set_rigsmal(bool const & value) { this->rigsmal = value; }
+
+        std::vector<Ruellia> const & get_ruellia() const { return ruellia; }
+        std::vector<Ruellia> & get_mutable_ruellia() { return ruellia; }
+        void set_ruellia(std::vector<Ruellia> const & value) { this->ruellia = value; }
+
+        std::vector<School> const & get_school() const { return school; }
+        std::vector<School> & get_mutable_school() { return school; }
+        void set_school(std::vector<School> const & value) { this->school = value; }
+
+        std::vector<Shakespearolater> const & get_shakespearolater() const { return shakespearolater; }
+        std::vector<Shakespearolater> & get_mutable_shakespearolater() { return shakespearolater; }
+        void set_shakespearolater(std::vector<Shakespearolater> const & value) { this->shakespearolater = value; }
+
+        std::vector<double> const & get_svan() const { return svan; }
+        std::vector<double> & get_mutable_svan() { return svan; }
+        void set_svan(std::vector<double> const & value) { this->svan = value; }
+
+        std::map<std::string, double> const & get_wayao() const { return wayao; }
+        std::map<std::string, double> & get_mutable_wayao() { return wayao; }
+        void set_wayao(std::map<std::string, double> const & value) { this->wayao = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(json const & j, AlleviateClass & x);
+void to_json(json & j, AlleviateClass const & x);
+
+void from_json(json const & j, Rebecca & x);
+void to_json(json & j, Rebecca const & x);
+
+void from_json(json const & j, Amphithyron & x);
+void to_json(json & j, Amphithyron const & x);
+
+void from_json(json const & j, AnkeeClass & x);
+void to_json(json & j, AnkeeClass const & x);
+
+void from_json(json const & j, AnsarieClass & x);
+void to_json(json & j, AnsarieClass const & x);
+
+void from_json(json const & j, ChytridiaceaeClass & x);
+void to_json(json & j, ChytridiaceaeClass const & x);
+
+void from_json(json const & j, DiscordiaClass & x);
+void to_json(json & j, DiscordiaClass const & x);
+
+void from_json(json const & j, GryphosaurusClass & x);
+void to_json(json & j, GryphosaurusClass const & x);
+
+void from_json(json const & j, LaviniaClass & x);
+void to_json(json & j, LaviniaClass const & x);
+
+void from_json(json const & j, OskarClass & x);
+void to_json(json & j, OskarClass const & x);
+
+void from_json(json const & j, TopLevel & x);
+void to_json(json & j, TopLevel const & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(json const & j, std::variant<bool, double> & x);
+    static void to_json(json & j, std::variant<bool, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::Rebecca, int64_t> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::Rebecca, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(json const & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, std::variant<double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double, std::string>> {
+    static void from_json(json const & j, std::variant<bool, double, std::string> & x);
+    static void to_json(json & j, std::variant<bool, double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::ChytridiaceaeClass> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::ChytridiaceaeClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<bool, int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<bool, int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>> {
+    static void from_json(json const & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x);
+    static void to_json(json & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LaviniaClass, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::LaviniaClass, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::LaviniaClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::Rebecca, int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::Rebecca, int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::Rebecca, std::string> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::Rebecca, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<int64_t, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, double, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, double, std::string> const & x);
+};
+}
+namespace quicktype {
+    inline void from_json(json const & j, AlleviateClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apriori(get_untyped(j, "apriori"));
+        x.set_beggarer(get_untyped(j, "beggarer"));
+        x.set_brokenheartedly(get_untyped(j, "brokenheartedly"));
+        x.set_debilitation(get_untyped(j, "debilitation"));
+        x.set_frike(get_untyped(j, "frike"));
+        x.set_gastrolith(get_untyped(j, "gastrolith"));
+        x.set_hulsean(get_untyped(j, "Hulsean"));
+        x.set_orthocentric(get_untyped(j, "orthocentric"));
+        x.set_petaly(get_untyped(j, "petaly"));
+        x.set_probudgeting(get_untyped(j, "probudgeting"));
+        x.set_reacquire(get_untyped(j, "reacquire"));
+        x.set_scow(get_untyped(j, "scow"));
+        x.set_shutoff(get_untyped(j, "shutoff"));
+        x.set_subcontiguous(get_untyped(j, "subcontiguous"));
+        x.set_suffumigate(get_untyped(j, "suffumigate"));
+        x.set_transformable(get_untyped(j, "transformable"));
+        x.set_uncoroneted(get_untyped(j, "uncoroneted"));
+        x.set_unparking(get_untyped(j, "unparking"));
+        x.set_unvarnishedness(get_untyped(j, "unvarnishedness"));
+        x.set_wherewithal(get_untyped(j, "wherewithal"));
+    }
+
+    inline void to_json(json & j, AlleviateClass const & x) {
+        j = json::object();
+        j["apriori"] = x.get_apriori();
+        j["beggarer"] = x.get_beggarer();
+        j["brokenheartedly"] = x.get_brokenheartedly();
+        j["debilitation"] = x.get_debilitation();
+        j["frike"] = x.get_frike();
+        j["gastrolith"] = x.get_gastrolith();
+        j["Hulsean"] = x.get_hulsean();
+        j["orthocentric"] = x.get_orthocentric();
+        j["petaly"] = x.get_petaly();
+        j["probudgeting"] = x.get_probudgeting();
+        j["reacquire"] = x.get_reacquire();
+        j["scow"] = x.get_scow();
+        j["shutoff"] = x.get_shutoff();
+        j["subcontiguous"] = x.get_subcontiguous();
+        j["suffumigate"] = x.get_suffumigate();
+        j["transformable"] = x.get_transformable();
+        j["uncoroneted"] = x.get_uncoroneted();
+        j["unparking"] = x.get_unparking();
+        j["unvarnishedness"] = x.get_unvarnishedness();
+        j["wherewithal"] = x.get_wherewithal();
+    }
+
+    inline void from_json(json const & j, Rebecca& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, Rebecca const & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(json const & j, Amphithyron& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_akroasis(get_stack_optional<int64_t>(j, "akroasis"));
+        x.set_antiphonical(get_stack_optional<int64_t>(j, "antiphonical"));
+        x.set_basebred(get_stack_optional<int64_t>(j, "basebred"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_conductometric(get_stack_optional<int64_t>(j, "conductometric"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ensilation(get_stack_optional<int64_t>(j, "ensilation"));
+        x.set_eyebolt(get_stack_optional<int64_t>(j, "eyebolt"));
+        x.set_fistulated(get_stack_optional<int64_t>(j, "fistulated"));
+        x.set_heteropod(get_stack_optional<int64_t>(j, "heteropod"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_juniperus(get_stack_optional<int64_t>(j, "Juniperus"));
+        x.set_labyrinthically(get_stack_optional<int64_t>(j, "labyrinthically"));
+        x.set_martyrization(get_stack_optional<int64_t>(j, "martyrization"));
+        x.set_mispolicy(get_stack_optional<int64_t>(j, "mispolicy"));
+        x.set_multipara(get_stack_optional<int64_t>(j, "multipara"));
+        x.set_nazirite(get_stack_optional<int64_t>(j, "Nazirite"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_possessorial(get_stack_optional<int64_t>(j, "possessorial"));
+        x.set_shamed(get_stack_optional<int64_t>(j, "shamed"));
+        x.set_shelfworn(get_stack_optional<int64_t>(j, "shelfworn"));
+        x.set_stagnum(get_stack_optional<int64_t>(j, "stagnum"));
+        x.set_those(get_stack_optional<int64_t>(j, "Those"));
+        x.set_undecimal(get_stack_optional<int64_t>(j, "undecimal"));
+    }
+
+    inline void to_json(json & j, Amphithyron const & x) {
+        j = json::object();
+        j["akroasis"] = x.get_akroasis();
+        j["antiphonical"] = x.get_antiphonical();
+        j["basebred"] = x.get_basebred();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["conductometric"] = x.get_conductometric();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ensilation"] = x.get_ensilation();
+        j["eyebolt"] = x.get_eyebolt();
+        j["fistulated"] = x.get_fistulated();
+        j["heteropod"] = x.get_heteropod();
+        j["homocerc"] = x.get_homocerc();
+        j["Juniperus"] = x.get_juniperus();
+        j["labyrinthically"] = x.get_labyrinthically();
+        j["martyrization"] = x.get_martyrization();
+        j["mispolicy"] = x.get_mispolicy();
+        j["multipara"] = x.get_multipara();
+        j["Nazirite"] = x.get_nazirite();
+        j["nonbookish"] = x.get_nonbookish();
+        j["possessorial"] = x.get_possessorial();
+        j["shamed"] = x.get_shamed();
+        j["shelfworn"] = x.get_shelfworn();
+        j["stagnum"] = x.get_stagnum();
+        j["Those"] = x.get_those();
+        j["undecimal"] = x.get_undecimal();
+    }
+
+    inline void from_json(json const & j, AnkeeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_anomoean(get_untyped(j, "Anomoean"));
+        x.set_barleyhood(get_untyped(j, "barleyhood"));
+        x.set_befriender(get_untyped(j, "befriender"));
+        x.set_brutishness(get_untyped(j, "brutishness"));
+        x.set_cephalalgy(get_untyped(j, "cephalalgy"));
+        x.set_cirurgian(get_untyped(j, "cirurgian"));
+        x.set_conventionally(get_untyped(j, "conventionally"));
+        x.set_jackshay(get_untyped(j, "jackshay"));
+        x.set_milammeter(get_untyped(j, "milammeter"));
+        x.set_naja(get_untyped(j, "Naja"));
+        x.set_ombrological(get_untyped(j, "ombrological"));
+        x.set_phonasthenia(get_untyped(j, "phonasthenia"));
+        x.set_retrievableness(get_untyped(j, "retrievableness"));
+        x.set_snakily(get_untyped(j, "snakily"));
+        x.set_swot(get_untyped(j, "swot"));
+        x.set_tartlet(get_untyped(j, "tartlet"));
+        x.set_thiofuran(get_untyped(j, "thiofuran"));
+        x.set_tracheophone(get_untyped(j, "tracheophone"));
+        x.set_tuglike(get_untyped(j, "tuglike"));
+        x.set_unscratchingly(get_untyped(j, "unscratchingly"));
+    }
+
+    inline void to_json(json & j, AnkeeClass const & x) {
+        j = json::object();
+        j["Anomoean"] = x.get_anomoean();
+        j["barleyhood"] = x.get_barleyhood();
+        j["befriender"] = x.get_befriender();
+        j["brutishness"] = x.get_brutishness();
+        j["cephalalgy"] = x.get_cephalalgy();
+        j["cirurgian"] = x.get_cirurgian();
+        j["conventionally"] = x.get_conventionally();
+        j["jackshay"] = x.get_jackshay();
+        j["milammeter"] = x.get_milammeter();
+        j["Naja"] = x.get_naja();
+        j["ombrological"] = x.get_ombrological();
+        j["phonasthenia"] = x.get_phonasthenia();
+        j["retrievableness"] = x.get_retrievableness();
+        j["snakily"] = x.get_snakily();
+        j["swot"] = x.get_swot();
+        j["tartlet"] = x.get_tartlet();
+        j["thiofuran"] = x.get_thiofuran();
+        j["tracheophone"] = x.get_tracheophone();
+        j["tuglike"] = x.get_tuglike();
+        j["unscratchingly"] = x.get_unscratchingly();
+    }
+
+    inline void from_json(json const & j, AnsarieClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_accension(get_untyped(j, "accension"));
+        x.set_alida(get_untyped(j, "Alida"));
+        x.set_asteria(get_untyped(j, "asteria"));
+        x.set_beriberic(get_untyped(j, "beriberic"));
+        x.set_edgebone(get_untyped(j, "edgebone"));
+        x.set_gastrodialysis(get_untyped(j, "gastrodialysis"));
+        x.set_geographic(get_untyped(j, "geographic"));
+        x.set_ictonyx(get_untyped(j, "Ictonyx"));
+        x.set_metrocele(get_untyped(j, "metrocele"));
+        x.set_misgraft(get_untyped(j, "misgraft"));
+        x.set_monteith(get_untyped(j, "monteith"));
+        x.set_notcher(get_untyped(j, "notcher"));
+        x.set_prorestriction(get_untyped(j, "prorestriction"));
+        x.set_ramist(get_untyped(j, "Ramist"));
+        x.set_throatlet(get_untyped(j, "throatlet"));
+        x.set_unfair(get_untyped(j, "unfair"));
+        x.set_unsynonymous(get_untyped(j, "unsynonymous"));
+        x.set_water(get_untyped(j, "water"));
+        x.set_zestfully(get_untyped(j, "zestfully"));
+        x.set_zincic(get_untyped(j, "zincic"));
+    }
+
+    inline void to_json(json & j, AnsarieClass const & x) {
+        j = json::object();
+        j["accension"] = x.get_accension();
+        j["Alida"] = x.get_alida();
+        j["asteria"] = x.get_asteria();
+        j["beriberic"] = x.get_beriberic();
+        j["edgebone"] = x.get_edgebone();
+        j["gastrodialysis"] = x.get_gastrodialysis();
+        j["geographic"] = x.get_geographic();
+        j["Ictonyx"] = x.get_ictonyx();
+        j["metrocele"] = x.get_metrocele();
+        j["misgraft"] = x.get_misgraft();
+        j["monteith"] = x.get_monteith();
+        j["notcher"] = x.get_notcher();
+        j["prorestriction"] = x.get_prorestriction();
+        j["Ramist"] = x.get_ramist();
+        j["throatlet"] = x.get_throatlet();
+        j["unfair"] = x.get_unfair();
+        j["unsynonymous"] = x.get_unsynonymous();
+        j["water"] = x.get_water();
+        j["zestfully"] = x.get_zestfully();
+        j["zincic"] = x.get_zincic();
+    }
+
+    inline void from_json(json const & j, ChytridiaceaeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_batidaceae(get_untyped(j, "Batidaceae"));
+        x.set_brechites(get_untyped(j, "Brechites"));
+        x.set_codespairer(get_untyped(j, "codespairer"));
+        x.set_emery(get_untyped(j, "Emery"));
+        x.set_enervative(get_untyped(j, "enervative"));
+        x.set_excriminate(get_untyped(j, "excriminate"));
+        x.set_goshenite(get_untyped(j, "goshenite"));
+        x.set_grime(get_untyped(j, "grime"));
+        x.set_gritten(get_untyped(j, "gritten"));
+        x.set_hectorly(get_untyped(j, "hectorly"));
+        x.set_intermediation(get_untyped(j, "intermediation"));
+        x.set_meeterly(get_untyped(j, "meeterly"));
+        x.set_narraganset(get_untyped(j, "Narraganset"));
+        x.set_onymatic(get_untyped(j, "onymatic"));
+        x.set_paddlecock(get_untyped(j, "paddlecock"));
+        x.set_thana(get_untyped(j, "thana"));
+        x.set_thornily(get_untyped(j, "thornily"));
+        x.set_uckia(get_untyped(j, "uckia"));
+        x.set_unmettle(get_untyped(j, "unmettle"));
+        x.set_vorticellid(get_untyped(j, "vorticellid"));
+    }
+
+    inline void to_json(json & j, ChytridiaceaeClass const & x) {
+        j = json::object();
+        j["Batidaceae"] = x.get_batidaceae();
+        j["Brechites"] = x.get_brechites();
+        j["codespairer"] = x.get_codespairer();
+        j["Emery"] = x.get_emery();
+        j["enervative"] = x.get_enervative();
+        j["excriminate"] = x.get_excriminate();
+        j["goshenite"] = x.get_goshenite();
+        j["grime"] = x.get_grime();
+        j["gritten"] = x.get_gritten();
+        j["hectorly"] = x.get_hectorly();
+        j["intermediation"] = x.get_intermediation();
+        j["meeterly"] = x.get_meeterly();
+        j["Narraganset"] = x.get_narraganset();
+        j["onymatic"] = x.get_onymatic();
+        j["paddlecock"] = x.get_paddlecock();
+        j["thana"] = x.get_thana();
+        j["thornily"] = x.get_thornily();
+        j["uckia"] = x.get_uckia();
+        j["unmettle"] = x.get_unmettle();
+        j["vorticellid"] = x.get_vorticellid();
+    }
+
+    inline void from_json(json const & j, DiscordiaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_altaic(get_stack_optional<int64_t>(j, "Altaic"));
+        x.set_amoristic(get_stack_optional<int64_t>(j, "amoristic"));
+        x.set_blennophthalmia(get_stack_optional<int64_t>(j, "blennophthalmia"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disciplinability(get_stack_optional<int64_t>(j, "disciplinability"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_goofer(get_stack_optional<int64_t>(j, "goofer"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_laryngograph(get_stack_optional<int64_t>(j, "laryngograph"));
+        x.set_leucitis(get_stack_optional<int64_t>(j, "leucitis"));
+        x.set_lymphocyst(get_stack_optional<int64_t>(j, "lymphocyst"));
+        x.set_microcosmology(get_stack_optional<int64_t>(j, "microcosmology"));
+        x.set_nauseation(get_stack_optional<int64_t>(j, "nauseation"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_patarin(get_stack_optional<int64_t>(j, "Patarin"));
+        x.set_preliberal(get_stack_optional<int64_t>(j, "preliberal"));
+        x.set_prettifier(get_stack_optional<int64_t>(j, "prettifier"));
+        x.set_rangework(get_stack_optional<int64_t>(j, "rangework"));
+        x.set_redient(get_stack_optional<int64_t>(j, "redient"));
+        x.set_subfusiform(get_stack_optional<int64_t>(j, "subfusiform"));
+        x.set_suicidical(get_stack_optional<int64_t>(j, "suicidical"));
+        x.set_swow(get_stack_optional<int64_t>(j, "swow"));
+        x.set_wastrel(get_stack_optional<int64_t>(j, "wastrel"));
+        x.set_wingle(get_stack_optional<int64_t>(j, "wingle"));
+    }
+
+    inline void to_json(json & j, DiscordiaClass const & x) {
+        j = json::object();
+        j["Altaic"] = x.get_altaic();
+        j["amoristic"] = x.get_amoristic();
+        j["blennophthalmia"] = x.get_blennophthalmia();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disciplinability"] = x.get_disciplinability();
+        j["disdiapason"] = x.get_disdiapason();
+        j["goofer"] = x.get_goofer();
+        j["homocerc"] = x.get_homocerc();
+        j["laryngograph"] = x.get_laryngograph();
+        j["leucitis"] = x.get_leucitis();
+        j["lymphocyst"] = x.get_lymphocyst();
+        j["microcosmology"] = x.get_microcosmology();
+        j["nauseation"] = x.get_nauseation();
+        j["nonbookish"] = x.get_nonbookish();
+        j["Patarin"] = x.get_patarin();
+        j["preliberal"] = x.get_preliberal();
+        j["prettifier"] = x.get_prettifier();
+        j["rangework"] = x.get_rangework();
+        j["redient"] = x.get_redient();
+        j["subfusiform"] = x.get_subfusiform();
+        j["suicidical"] = x.get_suicidical();
+        j["swow"] = x.get_swow();
+        j["wastrel"] = x.get_wastrel();
+        j["wingle"] = x.get_wingle();
+    }
+
+    inline void from_json(json const & j, GryphosaurusClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amissibility(get_untyped(j, "amissibility"));
+        x.set_burushaski(get_untyped(j, "Burushaski"));
+        x.set_citronin(get_untyped(j, "citronin"));
+        x.set_coplaintiff(get_untyped(j, "coplaintiff"));
+        x.set_disquisitionary(get_untyped(j, "disquisitionary"));
+        x.set_enoplan(get_untyped(j, "enoplan"));
+        x.set_faintness(get_untyped(j, "faintness"));
+        x.set_hebetomy(get_untyped(j, "hebetomy"));
+        x.set_islandry(get_untyped(j, "islandry"));
+        x.set_lameduck(get_untyped(j, "lameduck"));
+        x.set_overbattle(get_untyped(j, "overbattle"));
+        x.set_overinterested(get_untyped(j, "overinterested"));
+        x.set_phrenologic(get_untyped(j, "phrenologic"));
+        x.set_rainband(get_untyped(j, "rainband"));
+        x.set_shiningly(get_untyped(j, "shiningly"));
+        x.set_stamineous(get_untyped(j, "stamineous"));
+        x.set_subscapularis(get_untyped(j, "subscapularis"));
+        x.set_tahami(get_untyped(j, "Tahami"));
+        x.set_undaubed(get_untyped(j, "undaubed"));
+        x.set_underntime(get_untyped(j, "underntime"));
+    }
+
+    inline void to_json(json & j, GryphosaurusClass const & x) {
+        j = json::object();
+        j["amissibility"] = x.get_amissibility();
+        j["Burushaski"] = x.get_burushaski();
+        j["citronin"] = x.get_citronin();
+        j["coplaintiff"] = x.get_coplaintiff();
+        j["disquisitionary"] = x.get_disquisitionary();
+        j["enoplan"] = x.get_enoplan();
+        j["faintness"] = x.get_faintness();
+        j["hebetomy"] = x.get_hebetomy();
+        j["islandry"] = x.get_islandry();
+        j["lameduck"] = x.get_lameduck();
+        j["overbattle"] = x.get_overbattle();
+        j["overinterested"] = x.get_overinterested();
+        j["phrenologic"] = x.get_phrenologic();
+        j["rainband"] = x.get_rainband();
+        j["shiningly"] = x.get_shiningly();
+        j["stamineous"] = x.get_stamineous();
+        j["subscapularis"] = x.get_subscapularis();
+        j["Tahami"] = x.get_tahami();
+        j["undaubed"] = x.get_undaubed();
+        j["underntime"] = x.get_underntime();
+    }
+
+    inline void from_json(json const & j, LaviniaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_agitable(get_stack_optional<int64_t>(j, "agitable"));
+        x.set_asininity(get_stack_optional<int64_t>(j, "asininity"));
+        x.set_benefiter(get_stack_optional<int64_t>(j, "benefiter"));
+        x.set_bronzelike(get_stack_optional<int64_t>(j, "bronzelike"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_cholesteatomatous(get_stack_optional<int64_t>(j, "cholesteatomatous"));
+        x.set_deprivement(get_stack_optional<int64_t>(j, "deprivement"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_flippantness(get_stack_optional<int64_t>(j, "flippantness"));
+        x.set_fogproof(get_stack_optional<int64_t>(j, "fogproof"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_merrymeeting(get_stack_optional<int64_t>(j, "merrymeeting"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_overcareful(get_stack_optional<int64_t>(j, "overcareful"));
+        x.set_panaris(get_stack_optional<int64_t>(j, "panaris"));
+        x.set_preacceptance(get_stack_optional<int64_t>(j, "preacceptance"));
+        x.set_quinoxaline(get_stack_optional<int64_t>(j, "quinoxaline"));
+        x.set_sig(get_stack_optional<int64_t>(j, "sig"));
+        x.set_superconfusion(get_stack_optional<int64_t>(j, "superconfusion"));
+        x.set_tacana(get_stack_optional<int64_t>(j, "Tacana"));
+        x.set_tillotter(get_stack_optional<int64_t>(j, "tillotter"));
+        x.set_tranquillize(get_stack_optional<int64_t>(j, "tranquillize"));
+        x.set_unquestionable(get_stack_optional<int64_t>(j, "unquestionable"));
+        x.set_uproute(get_stack_optional<int64_t>(j, "uproute"));
+    }
+
+    inline void to_json(json & j, LaviniaClass const & x) {
+        j = json::object();
+        j["agitable"] = x.get_agitable();
+        j["asininity"] = x.get_asininity();
+        j["benefiter"] = x.get_benefiter();
+        j["bronzelike"] = x.get_bronzelike();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["cholesteatomatous"] = x.get_cholesteatomatous();
+        j["deprivement"] = x.get_deprivement();
+        j["disdiapason"] = x.get_disdiapason();
+        j["flippantness"] = x.get_flippantness();
+        j["fogproof"] = x.get_fogproof();
+        j["homocerc"] = x.get_homocerc();
+        j["merrymeeting"] = x.get_merrymeeting();
+        j["nonbookish"] = x.get_nonbookish();
+        j["overcareful"] = x.get_overcareful();
+        j["panaris"] = x.get_panaris();
+        j["preacceptance"] = x.get_preacceptance();
+        j["quinoxaline"] = x.get_quinoxaline();
+        j["sig"] = x.get_sig();
+        j["superconfusion"] = x.get_superconfusion();
+        j["Tacana"] = x.get_tacana();
+        j["tillotter"] = x.get_tillotter();
+        j["tranquillize"] = x.get_tranquillize();
+        j["unquestionable"] = x.get_unquestionable();
+        j["uproute"] = x.get_uproute();
+    }
+
+    inline void from_json(json const & j, OskarClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acrobates(get_untyped(j, "Acrobates"));
+        x.set_beanshooter(get_untyped(j, "beanshooter"));
+        x.set_bearhound(get_untyped(j, "bearhound"));
+        x.set_cayuga(get_untyped(j, "Cayuga"));
+        x.set_guarneri(get_untyped(j, "guarneri"));
+        x.set_hypochondriacism(get_untyped(j, "hypochondriacism"));
+        x.set_indication(get_untyped(j, "indication"));
+        x.set_jaculative(get_untyped(j, "jaculative"));
+        x.set_nagana(get_untyped(j, "nagana"));
+        x.set_netherlandish(get_untyped(j, "Netherlandish"));
+        x.set_noctivagous(get_untyped(j, "noctivagous"));
+        x.set_nonphysiological(get_untyped(j, "nonphysiological"));
+        x.set_praxis(get_untyped(j, "praxis"));
+        x.set_provision(get_untyped(j, "provision"));
+        x.set_subterhuman(get_untyped(j, "subterhuman"));
+        x.set_sunlit(get_untyped(j, "sunlit"));
+        x.set_syncraniate(get_untyped(j, "syncraniate"));
+        x.set_teachment(get_untyped(j, "teachment"));
+        x.set_unmutinous(get_untyped(j, "unmutinous"));
+        x.set_unstoppable(get_untyped(j, "unstoppable"));
+    }
+
+    inline void to_json(json & j, OskarClass const & x) {
+        j = json::object();
+        j["Acrobates"] = x.get_acrobates();
+        j["beanshooter"] = x.get_beanshooter();
+        j["bearhound"] = x.get_bearhound();
+        j["Cayuga"] = x.get_cayuga();
+        j["guarneri"] = x.get_guarneri();
+        j["hypochondriacism"] = x.get_hypochondriacism();
+        j["indication"] = x.get_indication();
+        j["jaculative"] = x.get_jaculative();
+        j["nagana"] = x.get_nagana();
+        j["Netherlandish"] = x.get_netherlandish();
+        j["noctivagous"] = x.get_noctivagous();
+        j["nonphysiological"] = x.get_nonphysiological();
+        j["praxis"] = x.get_praxis();
+        j["provision"] = x.get_provision();
+        j["subterhuman"] = x.get_subterhuman();
+        j["sunlit"] = x.get_sunlit();
+        j["syncraniate"] = x.get_syncraniate();
+        j["teachment"] = x.get_teachment();
+        j["unmutinous"] = x.get_unmutinous();
+        j["unstoppable"] = x.get_unstoppable();
+    }
+
+    inline void from_json(json const & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_abranchiata(j.at("Abranchiata").get<std::vector<Abranchiata>>());
+        x.set_academe(j.at("academe").get<std::vector<Academe>>());
+        x.set_acquirable(j.at("acquirable").get<std::vector<Acquirable>>());
+        x.set_aerometry(j.at("aerometry").get<std::vector<Aerometry>>());
+        x.set_alexin(j.at("alexin").get<std::vector<Alexin>>());
+        x.set_alleviate(j.at("alleviate").get<std::vector<AlleviateElement>>());
+        x.set_amaas(j.at("amaas").get<std::vector<Amaa>>());
+        x.set_ambassage(j.at("ambassage").get<std::vector<Ambassage>>());
+        x.set_amphithyron(j.at("amphithyron").get<std::vector<std::optional<Amphithyron>>>());
+        x.set_andriana(j.at("Andriana").get<std::vector<std::optional<std::string>>>());
+        x.set_ankee(j.at("ankee").get<std::vector<AnkeeElement>>());
+        x.set_annihilator(j.at("annihilator").get<std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>>>());
+        x.set_annulose(get_untyped(j, "annulose"));
+        x.set_ansarie(j.at("Ansarie").get<std::vector<AnsarieElement>>());
+        x.set_aphasia(j.at("aphasia").get<std::vector<Aphasia>>());
+        x.set_asprawl(j.at("asprawl").get<std::vector<Asprawl>>());
+        x.set_attractive(j.at("attractive").get<std::vector<std::optional<bool>>>());
+        x.set_barksome(j.at("barksome").get<std::map<std::string, int64_t>>());
+        x.set_bedesman(j.at("bedesman").get<std::vector<Bedesman>>());
+        x.set_belard(j.at("belard").get<std::vector<Belard>>());
+        x.set_bocking(j.at("bocking").get<std::vector<Bocking>>());
+        x.set_brawlingly(j.at("brawlingly").get<std::vector<Brawlingly>>());
+        x.set_brookie(j.at("brookie").get<std::vector<Brookie>>());
+        x.set_bumboatman(j.at("bumboatman").get<std::vector<Bumboatman>>());
+        x.set_bystreet(j.at("bystreet").get<std::vector<nlohmann::json>>());
+        x.set_calaverite(j.at("calaverite").get<std::vector<Calaverite>>());
+        x.set_catallactic(j.at("catallactic").get<std::vector<Catallactic>>());
+        x.set_cemental(j.at("cemental").get<std::vector<Cemental>>());
+        x.set_chytridiaceae(j.at("Chytridiaceae").get<std::vector<ChytridiaceaeElement>>());
+        x.set_discordia(j.at("Discordia").get<std::vector<DiscordiaElement>>());
+        x.set_endomyces(j.at("Endomyces").get<std::vector<Endomyce>>());
+        x.set_epinephelidae(j.at("Epinephelidae").get<std::vector<Epinephelidae>>());
+        x.set_eupatorium(j.at("Eupatorium").get<std::vector<Eupatorium>>());
+        x.set_gryphosaurus(j.at("Gryphosaurus").get<std::vector<GryphosaurusElement>>());
+        x.set_koryak(j.at("Koryak").get<std::vector<Koryak>>());
+        x.set_lavinia(j.at("Lavinia").get<std::vector<LaviniaElement>>());
+        x.set_oskar(j.at("Oskar").get<std::vector<OskarElement>>());
+        x.set_rebecca(j.at("Rebecca").get<std::vector<RebeccaElement>>());
+        x.set_rhomboganoidei(j.at("Rhomboganoidei").get<std::vector<Rhomboganoidei>>());
+        x.set_rigsmal(j.at("Rigsmal").get<bool>());
+        x.set_ruellia(j.at("Ruellia").get<std::vector<Ruellia>>());
+        x.set_school(j.at("School").get<std::vector<School>>());
+        x.set_shakespearolater(j.at("Shakespearolater").get<std::vector<Shakespearolater>>());
+        x.set_svan(j.at("Svan").get<std::vector<double>>());
+        x.set_wayao(j.at("Wayao").get<std::map<std::string, double>>());
+    }
+
+    inline void to_json(json & j, TopLevel const & x) {
+        j = json::object();
+        j["Abranchiata"] = x.get_abranchiata();
+        j["academe"] = x.get_academe();
+        j["acquirable"] = x.get_acquirable();
+        j["aerometry"] = x.get_aerometry();
+        j["alexin"] = x.get_alexin();
+        j["alleviate"] = x.get_alleviate();
+        j["amaas"] = x.get_amaas();
+        j["ambassage"] = x.get_ambassage();
+        j["amphithyron"] = x.get_amphithyron();
+        j["Andriana"] = x.get_andriana();
+        j["ankee"] = x.get_ankee();
+        j["annihilator"] = x.get_annihilator();
+        j["annulose"] = x.get_annulose();
+        j["Ansarie"] = x.get_ansarie();
+        j["aphasia"] = x.get_aphasia();
+        j["asprawl"] = x.get_asprawl();
+        j["attractive"] = x.get_attractive();
+        j["barksome"] = x.get_barksome();
+        j["bedesman"] = x.get_bedesman();
+        j["belard"] = x.get_belard();
+        j["bocking"] = x.get_bocking();
+        j["brawlingly"] = x.get_brawlingly();
+        j["brookie"] = x.get_brookie();
+        j["bumboatman"] = x.get_bumboatman();
+        j["bystreet"] = x.get_bystreet();
+        j["calaverite"] = x.get_calaverite();
+        j["catallactic"] = x.get_catallactic();
+        j["cemental"] = x.get_cemental();
+        j["Chytridiaceae"] = x.get_chytridiaceae();
+        j["Discordia"] = x.get_discordia();
+        j["Endomyces"] = x.get_endomyces();
+        j["Epinephelidae"] = x.get_epinephelidae();
+        j["Eupatorium"] = x.get_eupatorium();
+        j["Gryphosaurus"] = x.get_gryphosaurus();
+        j["Koryak"] = x.get_koryak();
+        j["Lavinia"] = x.get_lavinia();
+        j["Oskar"] = x.get_oskar();
+        j["Rebecca"] = x.get_rebecca();
+        j["Rhomboganoidei"] = x.get_rhomboganoidei();
+        j["Rigsmal"] = x.get_rigsmal();
+        j["Ruellia"] = x.get_ruellia();
+        j["School"] = x.get_school();
+        j["Shakespearolater"] = x.get_shakespearolater();
+        j["Svan"] = x.get_svan();
+        j["Wayao"] = x.get_wayao();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t>>::from_json(json const & j, std::variant<std::vector<int64_t>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t>>::to_json(json & j, std::variant<std::vector<int64_t>, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(json const & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, std::variant<bool, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::to_json(json & j, std::variant<std::vector<int64_t>, bool> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::AlleviateClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AlleviateClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>>::from_json(json const & j, std::variant<bool, quicktype::Rebecca, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>>::to_json(json & j, std::variant<bool, quicktype::Rebecca, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::string>>::from_json(json const & j, std::variant<std::vector<json>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::string>>::to_json(json & j, std::variant<std::vector<json>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::AnkeeClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AnkeeClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::AnsarieClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AnsarieClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(json const & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, std::variant<double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::string>>::from_json(json const & j, std::variant<bool, double, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::string>>::to_json(json & j, std::variant<bool, double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>>::from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>>::from_json(json const & j, std::variant<bool, quicktype::ChytridiaceaeClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::ChytridiaceaeClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>>::to_json(json & j, std::variant<bool, quicktype::ChytridiaceaeClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::ChytridiaceaeClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::DiscordiaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::DiscordiaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::from_json(json const & j, std::variant<int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::to_json(json & j, std::variant<int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::string>>::from_json(json const & j, std::variant<bool, int64_t, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::string>>::to_json(json & j, std::variant<bool, int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::GryphosaurusClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::GryphosaurusClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>>::from_json(json const & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>>::to_json(json & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LaviniaClass, std::string>>::from_json(json const & j, std::variant<quicktype::LaviniaClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::LaviniaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LaviniaClass, std::string>>::to_json(json & j, std::variant<quicktype::LaviniaClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LaviniaClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::OskarClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::OskarClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>>::from_json(json const & j, std::variant<quicktype::Rebecca, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>>::to_json(json & j, std::variant<quicktype::Rebecca, int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>>::from_json(json const & j, std::variant<bool, quicktype::Rebecca, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>>::to_json(json & j, std::variant<bool, quicktype::Rebecca, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<int64_t, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations2.json/default/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations2.json/default/quicktype.hpp
new file mode 100644
index 0000000..d05f74b
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations2.json/default/quicktype.hpp
@@ -0,0 +1,3029 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    using Abranchiata = std::optional<std::variant<std::vector<int64_t>, int64_t>>;
+
+    using Academe = std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>;
+
+    using Acquirable = std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>;
+
+    using Aerometry = std::variant<bool, double>;
+
+    using Alexin = std::variant<std::vector<int64_t>, bool>;
+
+    class AlleviateClass {
+        public:
+        AlleviateClass() = default;
+        virtual ~AlleviateClass() = default;
+
+        private:
+        nlohmann::json apriori;
+        nlohmann::json beggarer;
+        nlohmann::json brokenheartedly;
+        nlohmann::json debilitation;
+        nlohmann::json frike;
+        nlohmann::json gastrolith;
+        nlohmann::json hulsean;
+        nlohmann::json orthocentric;
+        nlohmann::json petaly;
+        nlohmann::json probudgeting;
+        nlohmann::json reacquire;
+        nlohmann::json scow;
+        nlohmann::json shutoff;
+        nlohmann::json subcontiguous;
+        nlohmann::json suffumigate;
+        nlohmann::json transformable;
+        nlohmann::json uncoroneted;
+        nlohmann::json unparking;
+        nlohmann::json unvarnishedness;
+        nlohmann::json wherewithal;
+
+        public:
+        const nlohmann::json & get_apriori() const { return apriori; }
+        nlohmann::json & get_mutable_apriori() { return apriori; }
+        void set_apriori(const nlohmann::json & value) { this->apriori = value; }
+
+        const nlohmann::json & get_beggarer() const { return beggarer; }
+        nlohmann::json & get_mutable_beggarer() { return beggarer; }
+        void set_beggarer(const nlohmann::json & value) { this->beggarer = value; }
+
+        const nlohmann::json & get_brokenheartedly() const { return brokenheartedly; }
+        nlohmann::json & get_mutable_brokenheartedly() { return brokenheartedly; }
+        void set_brokenheartedly(const nlohmann::json & value) { this->brokenheartedly = value; }
+
+        const nlohmann::json & get_debilitation() const { return debilitation; }
+        nlohmann::json & get_mutable_debilitation() { return debilitation; }
+        void set_debilitation(const nlohmann::json & value) { this->debilitation = value; }
+
+        const nlohmann::json & get_frike() const { return frike; }
+        nlohmann::json & get_mutable_frike() { return frike; }
+        void set_frike(const nlohmann::json & value) { this->frike = value; }
+
+        const nlohmann::json & get_gastrolith() const { return gastrolith; }
+        nlohmann::json & get_mutable_gastrolith() { return gastrolith; }
+        void set_gastrolith(const nlohmann::json & value) { this->gastrolith = value; }
+
+        const nlohmann::json & get_hulsean() const { return hulsean; }
+        nlohmann::json & get_mutable_hulsean() { return hulsean; }
+        void set_hulsean(const nlohmann::json & value) { this->hulsean = value; }
+
+        const nlohmann::json & get_orthocentric() const { return orthocentric; }
+        nlohmann::json & get_mutable_orthocentric() { return orthocentric; }
+        void set_orthocentric(const nlohmann::json & value) { this->orthocentric = value; }
+
+        const nlohmann::json & get_petaly() const { return petaly; }
+        nlohmann::json & get_mutable_petaly() { return petaly; }
+        void set_petaly(const nlohmann::json & value) { this->petaly = value; }
+
+        const nlohmann::json & get_probudgeting() const { return probudgeting; }
+        nlohmann::json & get_mutable_probudgeting() { return probudgeting; }
+        void set_probudgeting(const nlohmann::json & value) { this->probudgeting = value; }
+
+        const nlohmann::json & get_reacquire() const { return reacquire; }
+        nlohmann::json & get_mutable_reacquire() { return reacquire; }
+        void set_reacquire(const nlohmann::json & value) { this->reacquire = value; }
+
+        const nlohmann::json & get_scow() const { return scow; }
+        nlohmann::json & get_mutable_scow() { return scow; }
+        void set_scow(const nlohmann::json & value) { this->scow = value; }
+
+        const nlohmann::json & get_shutoff() const { return shutoff; }
+        nlohmann::json & get_mutable_shutoff() { return shutoff; }
+        void set_shutoff(const nlohmann::json & value) { this->shutoff = value; }
+
+        const nlohmann::json & get_subcontiguous() const { return subcontiguous; }
+        nlohmann::json & get_mutable_subcontiguous() { return subcontiguous; }
+        void set_subcontiguous(const nlohmann::json & value) { this->subcontiguous = value; }
+
+        const nlohmann::json & get_suffumigate() const { return suffumigate; }
+        nlohmann::json & get_mutable_suffumigate() { return suffumigate; }
+        void set_suffumigate(const nlohmann::json & value) { this->suffumigate = value; }
+
+        const nlohmann::json & get_transformable() const { return transformable; }
+        nlohmann::json & get_mutable_transformable() { return transformable; }
+        void set_transformable(const nlohmann::json & value) { this->transformable = value; }
+
+        const nlohmann::json & get_uncoroneted() const { return uncoroneted; }
+        nlohmann::json & get_mutable_uncoroneted() { return uncoroneted; }
+        void set_uncoroneted(const nlohmann::json & value) { this->uncoroneted = value; }
+
+        const nlohmann::json & get_unparking() const { return unparking; }
+        nlohmann::json & get_mutable_unparking() { return unparking; }
+        void set_unparking(const nlohmann::json & value) { this->unparking = value; }
+
+        const nlohmann::json & get_unvarnishedness() const { return unvarnishedness; }
+        nlohmann::json & get_mutable_unvarnishedness() { return unvarnishedness; }
+        void set_unvarnishedness(const nlohmann::json & value) { this->unvarnishedness = value; }
+
+        const nlohmann::json & get_wherewithal() const { return wherewithal; }
+        nlohmann::json & get_mutable_wherewithal() { return wherewithal; }
+        void set_wherewithal(const nlohmann::json & value) { this->wherewithal = value; }
+    };
+
+    using AlleviateElement = std::variant<std::vector<std::optional<int64_t>>, AlleviateClass>;
+
+    class Rebecca {
+        public:
+        Rebecca() = default;
+        virtual ~Rebecca() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        const double & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const double & value) { this->catharticalness = value; }
+
+        const int64_t & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const int64_t & value) { this->chirotherium = value; }
+
+        const std::string & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::string & value) { this->disdiapason = value; }
+
+        const bool & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const bool & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+    };
+
+    using Amaa = std::variant<bool, Rebecca, int64_t>;
+
+    using Ambassage = std::variant<std::vector<nlohmann::json>, std::string>;
+
+    class Amphithyron {
+        public:
+        Amphithyron() = default;
+        virtual ~Amphithyron() = default;
+
+        private:
+        std::optional<int64_t> akroasis;
+        std::optional<int64_t> antiphonical;
+        std::optional<int64_t> basebred;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> conductometric;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ensilation;
+        std::optional<int64_t> eyebolt;
+        std::optional<int64_t> fistulated;
+        std::optional<int64_t> heteropod;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> juniperus;
+        std::optional<int64_t> labyrinthically;
+        std::optional<int64_t> martyrization;
+        std::optional<int64_t> mispolicy;
+        std::optional<int64_t> multipara;
+        std::optional<int64_t> nazirite;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> possessorial;
+        std::optional<int64_t> shamed;
+        std::optional<int64_t> shelfworn;
+        std::optional<int64_t> stagnum;
+        std::optional<int64_t> those;
+        std::optional<int64_t> undecimal;
+
+        public:
+        const std::optional<int64_t> & get_akroasis() const { return akroasis; }
+        std::optional<int64_t> & get_mutable_akroasis() { return akroasis; }
+        void set_akroasis(const std::optional<int64_t> & value) { this->akroasis = value; }
+
+        const std::optional<int64_t> & get_antiphonical() const { return antiphonical; }
+        std::optional<int64_t> & get_mutable_antiphonical() { return antiphonical; }
+        void set_antiphonical(const std::optional<int64_t> & value) { this->antiphonical = value; }
+
+        const std::optional<int64_t> & get_basebred() const { return basebred; }
+        std::optional<int64_t> & get_mutable_basebred() { return basebred; }
+        void set_basebred(const std::optional<int64_t> & value) { this->basebred = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_conductometric() const { return conductometric; }
+        std::optional<int64_t> & get_mutable_conductometric() { return conductometric; }
+        void set_conductometric(const std::optional<int64_t> & value) { this->conductometric = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_ensilation() const { return ensilation; }
+        std::optional<int64_t> & get_mutable_ensilation() { return ensilation; }
+        void set_ensilation(const std::optional<int64_t> & value) { this->ensilation = value; }
+
+        const std::optional<int64_t> & get_eyebolt() const { return eyebolt; }
+        std::optional<int64_t> & get_mutable_eyebolt() { return eyebolt; }
+        void set_eyebolt(const std::optional<int64_t> & value) { this->eyebolt = value; }
+
+        const std::optional<int64_t> & get_fistulated() const { return fistulated; }
+        std::optional<int64_t> & get_mutable_fistulated() { return fistulated; }
+        void set_fistulated(const std::optional<int64_t> & value) { this->fistulated = value; }
+
+        const std::optional<int64_t> & get_heteropod() const { return heteropod; }
+        std::optional<int64_t> & get_mutable_heteropod() { return heteropod; }
+        void set_heteropod(const std::optional<int64_t> & value) { this->heteropod = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_juniperus() const { return juniperus; }
+        std::optional<int64_t> & get_mutable_juniperus() { return juniperus; }
+        void set_juniperus(const std::optional<int64_t> & value) { this->juniperus = value; }
+
+        const std::optional<int64_t> & get_labyrinthically() const { return labyrinthically; }
+        std::optional<int64_t> & get_mutable_labyrinthically() { return labyrinthically; }
+        void set_labyrinthically(const std::optional<int64_t> & value) { this->labyrinthically = value; }
+
+        const std::optional<int64_t> & get_martyrization() const { return martyrization; }
+        std::optional<int64_t> & get_mutable_martyrization() { return martyrization; }
+        void set_martyrization(const std::optional<int64_t> & value) { this->martyrization = value; }
+
+        const std::optional<int64_t> & get_mispolicy() const { return mispolicy; }
+        std::optional<int64_t> & get_mutable_mispolicy() { return mispolicy; }
+        void set_mispolicy(const std::optional<int64_t> & value) { this->mispolicy = value; }
+
+        const std::optional<int64_t> & get_multipara() const { return multipara; }
+        std::optional<int64_t> & get_mutable_multipara() { return multipara; }
+        void set_multipara(const std::optional<int64_t> & value) { this->multipara = value; }
+
+        const std::optional<int64_t> & get_nazirite() const { return nazirite; }
+        std::optional<int64_t> & get_mutable_nazirite() { return nazirite; }
+        void set_nazirite(const std::optional<int64_t> & value) { this->nazirite = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_possessorial() const { return possessorial; }
+        std::optional<int64_t> & get_mutable_possessorial() { return possessorial; }
+        void set_possessorial(const std::optional<int64_t> & value) { this->possessorial = value; }
+
+        const std::optional<int64_t> & get_shamed() const { return shamed; }
+        std::optional<int64_t> & get_mutable_shamed() { return shamed; }
+        void set_shamed(const std::optional<int64_t> & value) { this->shamed = value; }
+
+        const std::optional<int64_t> & get_shelfworn() const { return shelfworn; }
+        std::optional<int64_t> & get_mutable_shelfworn() { return shelfworn; }
+        void set_shelfworn(const std::optional<int64_t> & value) { this->shelfworn = value; }
+
+        const std::optional<int64_t> & get_stagnum() const { return stagnum; }
+        std::optional<int64_t> & get_mutable_stagnum() { return stagnum; }
+        void set_stagnum(const std::optional<int64_t> & value) { this->stagnum = value; }
+
+        const std::optional<int64_t> & get_those() const { return those; }
+        std::optional<int64_t> & get_mutable_those() { return those; }
+        void set_those(const std::optional<int64_t> & value) { this->those = value; }
+
+        const std::optional<int64_t> & get_undecimal() const { return undecimal; }
+        std::optional<int64_t> & get_mutable_undecimal() { return undecimal; }
+        void set_undecimal(const std::optional<int64_t> & value) { this->undecimal = value; }
+    };
+
+    class AnkeeClass {
+        public:
+        AnkeeClass() = default;
+        virtual ~AnkeeClass() = default;
+
+        private:
+        nlohmann::json anomoean;
+        nlohmann::json barleyhood;
+        nlohmann::json befriender;
+        nlohmann::json brutishness;
+        nlohmann::json cephalalgy;
+        nlohmann::json cirurgian;
+        nlohmann::json conventionally;
+        nlohmann::json jackshay;
+        nlohmann::json milammeter;
+        nlohmann::json naja;
+        nlohmann::json ombrological;
+        nlohmann::json phonasthenia;
+        nlohmann::json retrievableness;
+        nlohmann::json snakily;
+        nlohmann::json swot;
+        nlohmann::json tartlet;
+        nlohmann::json thiofuran;
+        nlohmann::json tracheophone;
+        nlohmann::json tuglike;
+        nlohmann::json unscratchingly;
+
+        public:
+        const nlohmann::json & get_anomoean() const { return anomoean; }
+        nlohmann::json & get_mutable_anomoean() { return anomoean; }
+        void set_anomoean(const nlohmann::json & value) { this->anomoean = value; }
+
+        const nlohmann::json & get_barleyhood() const { return barleyhood; }
+        nlohmann::json & get_mutable_barleyhood() { return barleyhood; }
+        void set_barleyhood(const nlohmann::json & value) { this->barleyhood = value; }
+
+        const nlohmann::json & get_befriender() const { return befriender; }
+        nlohmann::json & get_mutable_befriender() { return befriender; }
+        void set_befriender(const nlohmann::json & value) { this->befriender = value; }
+
+        const nlohmann::json & get_brutishness() const { return brutishness; }
+        nlohmann::json & get_mutable_brutishness() { return brutishness; }
+        void set_brutishness(const nlohmann::json & value) { this->brutishness = value; }
+
+        const nlohmann::json & get_cephalalgy() const { return cephalalgy; }
+        nlohmann::json & get_mutable_cephalalgy() { return cephalalgy; }
+        void set_cephalalgy(const nlohmann::json & value) { this->cephalalgy = value; }
+
+        const nlohmann::json & get_cirurgian() const { return cirurgian; }
+        nlohmann::json & get_mutable_cirurgian() { return cirurgian; }
+        void set_cirurgian(const nlohmann::json & value) { this->cirurgian = value; }
+
+        const nlohmann::json & get_conventionally() const { return conventionally; }
+        nlohmann::json & get_mutable_conventionally() { return conventionally; }
+        void set_conventionally(const nlohmann::json & value) { this->conventionally = value; }
+
+        const nlohmann::json & get_jackshay() const { return jackshay; }
+        nlohmann::json & get_mutable_jackshay() { return jackshay; }
+        void set_jackshay(const nlohmann::json & value) { this->jackshay = value; }
+
+        const nlohmann::json & get_milammeter() const { return milammeter; }
+        nlohmann::json & get_mutable_milammeter() { return milammeter; }
+        void set_milammeter(const nlohmann::json & value) { this->milammeter = value; }
+
+        const nlohmann::json & get_naja() const { return naja; }
+        nlohmann::json & get_mutable_naja() { return naja; }
+        void set_naja(const nlohmann::json & value) { this->naja = value; }
+
+        const nlohmann::json & get_ombrological() const { return ombrological; }
+        nlohmann::json & get_mutable_ombrological() { return ombrological; }
+        void set_ombrological(const nlohmann::json & value) { this->ombrological = value; }
+
+        const nlohmann::json & get_phonasthenia() const { return phonasthenia; }
+        nlohmann::json & get_mutable_phonasthenia() { return phonasthenia; }
+        void set_phonasthenia(const nlohmann::json & value) { this->phonasthenia = value; }
+
+        const nlohmann::json & get_retrievableness() const { return retrievableness; }
+        nlohmann::json & get_mutable_retrievableness() { return retrievableness; }
+        void set_retrievableness(const nlohmann::json & value) { this->retrievableness = value; }
+
+        const nlohmann::json & get_snakily() const { return snakily; }
+        nlohmann::json & get_mutable_snakily() { return snakily; }
+        void set_snakily(const nlohmann::json & value) { this->snakily = value; }
+
+        const nlohmann::json & get_swot() const { return swot; }
+        nlohmann::json & get_mutable_swot() { return swot; }
+        void set_swot(const nlohmann::json & value) { this->swot = value; }
+
+        const nlohmann::json & get_tartlet() const { return tartlet; }
+        nlohmann::json & get_mutable_tartlet() { return tartlet; }
+        void set_tartlet(const nlohmann::json & value) { this->tartlet = value; }
+
+        const nlohmann::json & get_thiofuran() const { return thiofuran; }
+        nlohmann::json & get_mutable_thiofuran() { return thiofuran; }
+        void set_thiofuran(const nlohmann::json & value) { this->thiofuran = value; }
+
+        const nlohmann::json & get_tracheophone() const { return tracheophone; }
+        nlohmann::json & get_mutable_tracheophone() { return tracheophone; }
+        void set_tracheophone(const nlohmann::json & value) { this->tracheophone = value; }
+
+        const nlohmann::json & get_tuglike() const { return tuglike; }
+        nlohmann::json & get_mutable_tuglike() { return tuglike; }
+        void set_tuglike(const nlohmann::json & value) { this->tuglike = value; }
+
+        const nlohmann::json & get_unscratchingly() const { return unscratchingly; }
+        nlohmann::json & get_mutable_unscratchingly() { return unscratchingly; }
+        void set_unscratchingly(const nlohmann::json & value) { this->unscratchingly = value; }
+    };
+
+    using AnkeeElement = std::variant<std::vector<int64_t>, AnkeeClass, int64_t>;
+
+    class AnsarieClass {
+        public:
+        AnsarieClass() = default;
+        virtual ~AnsarieClass() = default;
+
+        private:
+        nlohmann::json accension;
+        nlohmann::json alida;
+        nlohmann::json asteria;
+        nlohmann::json beriberic;
+        nlohmann::json edgebone;
+        nlohmann::json gastrodialysis;
+        nlohmann::json geographic;
+        nlohmann::json ictonyx;
+        nlohmann::json metrocele;
+        nlohmann::json misgraft;
+        nlohmann::json monteith;
+        nlohmann::json notcher;
+        nlohmann::json prorestriction;
+        nlohmann::json ramist;
+        nlohmann::json throatlet;
+        nlohmann::json unfair;
+        nlohmann::json unsynonymous;
+        nlohmann::json water;
+        nlohmann::json zestfully;
+        nlohmann::json zincic;
+
+        public:
+        const nlohmann::json & get_accension() const { return accension; }
+        nlohmann::json & get_mutable_accension() { return accension; }
+        void set_accension(const nlohmann::json & value) { this->accension = value; }
+
+        const nlohmann::json & get_alida() const { return alida; }
+        nlohmann::json & get_mutable_alida() { return alida; }
+        void set_alida(const nlohmann::json & value) { this->alida = value; }
+
+        const nlohmann::json & get_asteria() const { return asteria; }
+        nlohmann::json & get_mutable_asteria() { return asteria; }
+        void set_asteria(const nlohmann::json & value) { this->asteria = value; }
+
+        const nlohmann::json & get_beriberic() const { return beriberic; }
+        nlohmann::json & get_mutable_beriberic() { return beriberic; }
+        void set_beriberic(const nlohmann::json & value) { this->beriberic = value; }
+
+        const nlohmann::json & get_edgebone() const { return edgebone; }
+        nlohmann::json & get_mutable_edgebone() { return edgebone; }
+        void set_edgebone(const nlohmann::json & value) { this->edgebone = value; }
+
+        const nlohmann::json & get_gastrodialysis() const { return gastrodialysis; }
+        nlohmann::json & get_mutable_gastrodialysis() { return gastrodialysis; }
+        void set_gastrodialysis(const nlohmann::json & value) { this->gastrodialysis = value; }
+
+        const nlohmann::json & get_geographic() const { return geographic; }
+        nlohmann::json & get_mutable_geographic() { return geographic; }
+        void set_geographic(const nlohmann::json & value) { this->geographic = value; }
+
+        const nlohmann::json & get_ictonyx() const { return ictonyx; }
+        nlohmann::json & get_mutable_ictonyx() { return ictonyx; }
+        void set_ictonyx(const nlohmann::json & value) { this->ictonyx = value; }
+
+        const nlohmann::json & get_metrocele() const { return metrocele; }
+        nlohmann::json & get_mutable_metrocele() { return metrocele; }
+        void set_metrocele(const nlohmann::json & value) { this->metrocele = value; }
+
+        const nlohmann::json & get_misgraft() const { return misgraft; }
+        nlohmann::json & get_mutable_misgraft() { return misgraft; }
+        void set_misgraft(const nlohmann::json & value) { this->misgraft = value; }
+
+        const nlohmann::json & get_monteith() const { return monteith; }
+        nlohmann::json & get_mutable_monteith() { return monteith; }
+        void set_monteith(const nlohmann::json & value) { this->monteith = value; }
+
+        const nlohmann::json & get_notcher() const { return notcher; }
+        nlohmann::json & get_mutable_notcher() { return notcher; }
+        void set_notcher(const nlohmann::json & value) { this->notcher = value; }
+
+        const nlohmann::json & get_prorestriction() const { return prorestriction; }
+        nlohmann::json & get_mutable_prorestriction() { return prorestriction; }
+        void set_prorestriction(const nlohmann::json & value) { this->prorestriction = value; }
+
+        const nlohmann::json & get_ramist() const { return ramist; }
+        nlohmann::json & get_mutable_ramist() { return ramist; }
+        void set_ramist(const nlohmann::json & value) { this->ramist = value; }
+
+        const nlohmann::json & get_throatlet() const { return throatlet; }
+        nlohmann::json & get_mutable_throatlet() { return throatlet; }
+        void set_throatlet(const nlohmann::json & value) { this->throatlet = value; }
+
+        const nlohmann::json & get_unfair() const { return unfair; }
+        nlohmann::json & get_mutable_unfair() { return unfair; }
+        void set_unfair(const nlohmann::json & value) { this->unfair = value; }
+
+        const nlohmann::json & get_unsynonymous() const { return unsynonymous; }
+        nlohmann::json & get_mutable_unsynonymous() { return unsynonymous; }
+        void set_unsynonymous(const nlohmann::json & value) { this->unsynonymous = value; }
+
+        const nlohmann::json & get_water() const { return water; }
+        nlohmann::json & get_mutable_water() { return water; }
+        void set_water(const nlohmann::json & value) { this->water = value; }
+
+        const nlohmann::json & get_zestfully() const { return zestfully; }
+        nlohmann::json & get_mutable_zestfully() { return zestfully; }
+        void set_zestfully(const nlohmann::json & value) { this->zestfully = value; }
+
+        const nlohmann::json & get_zincic() const { return zincic; }
+        nlohmann::json & get_mutable_zincic() { return zincic; }
+        void set_zincic(const nlohmann::json & value) { this->zincic = value; }
+    };
+
+    using AnsarieElement = std::optional<std::variant<std::vector<int64_t>, AnsarieClass>>;
+
+    using Aphasia = std::variant<std::vector<int64_t>, int64_t>;
+
+    using Asprawl = std::variant<double, std::string>;
+
+    using Bedesman = std::variant<bool, double, std::string>;
+
+    using Belard = std::variant<std::vector<int64_t>, Rebecca, double>;
+
+    using Bocking = std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>;
+
+    using Brawlingly = std::variant<std::vector<nlohmann::json>, std::map<std::string, std::optional<int64_t>>>;
+
+    using Brookie = std::variant<std::vector<int64_t>, Rebecca>;
+
+    using Bumboatman = std::optional<std::variant<std::vector<nlohmann::json>, std::string>>;
+
+    using Calaverite = std::variant<std::vector<int64_t>, std::string>;
+
+    using Catallactic = std::variant<std::vector<nlohmann::json>, bool, std::map<std::string, int64_t>>;
+
+    using Cemental = std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>;
+
+    class ChytridiaceaeClass {
+        public:
+        ChytridiaceaeClass() = default;
+        virtual ~ChytridiaceaeClass() = default;
+
+        private:
+        nlohmann::json batidaceae;
+        nlohmann::json brechites;
+        nlohmann::json codespairer;
+        nlohmann::json emery;
+        nlohmann::json enervative;
+        nlohmann::json excriminate;
+        nlohmann::json goshenite;
+        nlohmann::json grime;
+        nlohmann::json gritten;
+        nlohmann::json hectorly;
+        nlohmann::json intermediation;
+        nlohmann::json meeterly;
+        nlohmann::json narraganset;
+        nlohmann::json onymatic;
+        nlohmann::json paddlecock;
+        nlohmann::json thana;
+        nlohmann::json thornily;
+        nlohmann::json uckia;
+        nlohmann::json unmettle;
+        nlohmann::json vorticellid;
+
+        public:
+        const nlohmann::json & get_batidaceae() const { return batidaceae; }
+        nlohmann::json & get_mutable_batidaceae() { return batidaceae; }
+        void set_batidaceae(const nlohmann::json & value) { this->batidaceae = value; }
+
+        const nlohmann::json & get_brechites() const { return brechites; }
+        nlohmann::json & get_mutable_brechites() { return brechites; }
+        void set_brechites(const nlohmann::json & value) { this->brechites = value; }
+
+        const nlohmann::json & get_codespairer() const { return codespairer; }
+        nlohmann::json & get_mutable_codespairer() { return codespairer; }
+        void set_codespairer(const nlohmann::json & value) { this->codespairer = value; }
+
+        const nlohmann::json & get_emery() const { return emery; }
+        nlohmann::json & get_mutable_emery() { return emery; }
+        void set_emery(const nlohmann::json & value) { this->emery = value; }
+
+        const nlohmann::json & get_enervative() const { return enervative; }
+        nlohmann::json & get_mutable_enervative() { return enervative; }
+        void set_enervative(const nlohmann::json & value) { this->enervative = value; }
+
+        const nlohmann::json & get_excriminate() const { return excriminate; }
+        nlohmann::json & get_mutable_excriminate() { return excriminate; }
+        void set_excriminate(const nlohmann::json & value) { this->excriminate = value; }
+
+        const nlohmann::json & get_goshenite() const { return goshenite; }
+        nlohmann::json & get_mutable_goshenite() { return goshenite; }
+        void set_goshenite(const nlohmann::json & value) { this->goshenite = value; }
+
+        const nlohmann::json & get_grime() const { return grime; }
+        nlohmann::json & get_mutable_grime() { return grime; }
+        void set_grime(const nlohmann::json & value) { this->grime = value; }
+
+        const nlohmann::json & get_gritten() const { return gritten; }
+        nlohmann::json & get_mutable_gritten() { return gritten; }
+        void set_gritten(const nlohmann::json & value) { this->gritten = value; }
+
+        const nlohmann::json & get_hectorly() const { return hectorly; }
+        nlohmann::json & get_mutable_hectorly() { return hectorly; }
+        void set_hectorly(const nlohmann::json & value) { this->hectorly = value; }
+
+        const nlohmann::json & get_intermediation() const { return intermediation; }
+        nlohmann::json & get_mutable_intermediation() { return intermediation; }
+        void set_intermediation(const nlohmann::json & value) { this->intermediation = value; }
+
+        const nlohmann::json & get_meeterly() const { return meeterly; }
+        nlohmann::json & get_mutable_meeterly() { return meeterly; }
+        void set_meeterly(const nlohmann::json & value) { this->meeterly = value; }
+
+        const nlohmann::json & get_narraganset() const { return narraganset; }
+        nlohmann::json & get_mutable_narraganset() { return narraganset; }
+        void set_narraganset(const nlohmann::json & value) { this->narraganset = value; }
+
+        const nlohmann::json & get_onymatic() const { return onymatic; }
+        nlohmann::json & get_mutable_onymatic() { return onymatic; }
+        void set_onymatic(const nlohmann::json & value) { this->onymatic = value; }
+
+        const nlohmann::json & get_paddlecock() const { return paddlecock; }
+        nlohmann::json & get_mutable_paddlecock() { return paddlecock; }
+        void set_paddlecock(const nlohmann::json & value) { this->paddlecock = value; }
+
+        const nlohmann::json & get_thana() const { return thana; }
+        nlohmann::json & get_mutable_thana() { return thana; }
+        void set_thana(const nlohmann::json & value) { this->thana = value; }
+
+        const nlohmann::json & get_thornily() const { return thornily; }
+        nlohmann::json & get_mutable_thornily() { return thornily; }
+        void set_thornily(const nlohmann::json & value) { this->thornily = value; }
+
+        const nlohmann::json & get_uckia() const { return uckia; }
+        nlohmann::json & get_mutable_uckia() { return uckia; }
+        void set_uckia(const nlohmann::json & value) { this->uckia = value; }
+
+        const nlohmann::json & get_unmettle() const { return unmettle; }
+        nlohmann::json & get_mutable_unmettle() { return unmettle; }
+        void set_unmettle(const nlohmann::json & value) { this->unmettle = value; }
+
+        const nlohmann::json & get_vorticellid() const { return vorticellid; }
+        nlohmann::json & get_mutable_vorticellid() { return vorticellid; }
+        void set_vorticellid(const nlohmann::json & value) { this->vorticellid = value; }
+    };
+
+    using ChytridiaceaeElement = std::optional<std::variant<bool, ChytridiaceaeClass>>;
+
+    class DiscordiaClass {
+        public:
+        DiscordiaClass() = default;
+        virtual ~DiscordiaClass() = default;
+
+        private:
+        std::optional<int64_t> altaic;
+        std::optional<int64_t> amoristic;
+        std::optional<int64_t> blennophthalmia;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> disciplinability;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> goofer;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> laryngograph;
+        std::optional<int64_t> leucitis;
+        std::optional<int64_t> lymphocyst;
+        std::optional<int64_t> microcosmology;
+        std::optional<int64_t> nauseation;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> patarin;
+        std::optional<int64_t> preliberal;
+        std::optional<int64_t> prettifier;
+        std::optional<int64_t> rangework;
+        std::optional<int64_t> redient;
+        std::optional<int64_t> subfusiform;
+        std::optional<int64_t> suicidical;
+        std::optional<int64_t> swow;
+        std::optional<int64_t> wastrel;
+        std::optional<int64_t> wingle;
+
+        public:
+        const std::optional<int64_t> & get_altaic() const { return altaic; }
+        std::optional<int64_t> & get_mutable_altaic() { return altaic; }
+        void set_altaic(const std::optional<int64_t> & value) { this->altaic = value; }
+
+        const std::optional<int64_t> & get_amoristic() const { return amoristic; }
+        std::optional<int64_t> & get_mutable_amoristic() { return amoristic; }
+        void set_amoristic(const std::optional<int64_t> & value) { this->amoristic = value; }
+
+        const std::optional<int64_t> & get_blennophthalmia() const { return blennophthalmia; }
+        std::optional<int64_t> & get_mutable_blennophthalmia() { return blennophthalmia; }
+        void set_blennophthalmia(const std::optional<int64_t> & value) { this->blennophthalmia = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_disciplinability() const { return disciplinability; }
+        std::optional<int64_t> & get_mutable_disciplinability() { return disciplinability; }
+        void set_disciplinability(const std::optional<int64_t> & value) { this->disciplinability = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_goofer() const { return goofer; }
+        std::optional<int64_t> & get_mutable_goofer() { return goofer; }
+        void set_goofer(const std::optional<int64_t> & value) { this->goofer = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_laryngograph() const { return laryngograph; }
+        std::optional<int64_t> & get_mutable_laryngograph() { return laryngograph; }
+        void set_laryngograph(const std::optional<int64_t> & value) { this->laryngograph = value; }
+
+        const std::optional<int64_t> & get_leucitis() const { return leucitis; }
+        std::optional<int64_t> & get_mutable_leucitis() { return leucitis; }
+        void set_leucitis(const std::optional<int64_t> & value) { this->leucitis = value; }
+
+        const std::optional<int64_t> & get_lymphocyst() const { return lymphocyst; }
+        std::optional<int64_t> & get_mutable_lymphocyst() { return lymphocyst; }
+        void set_lymphocyst(const std::optional<int64_t> & value) { this->lymphocyst = value; }
+
+        const std::optional<int64_t> & get_microcosmology() const { return microcosmology; }
+        std::optional<int64_t> & get_mutable_microcosmology() { return microcosmology; }
+        void set_microcosmology(const std::optional<int64_t> & value) { this->microcosmology = value; }
+
+        const std::optional<int64_t> & get_nauseation() const { return nauseation; }
+        std::optional<int64_t> & get_mutable_nauseation() { return nauseation; }
+        void set_nauseation(const std::optional<int64_t> & value) { this->nauseation = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_patarin() const { return patarin; }
+        std::optional<int64_t> & get_mutable_patarin() { return patarin; }
+        void set_patarin(const std::optional<int64_t> & value) { this->patarin = value; }
+
+        const std::optional<int64_t> & get_preliberal() const { return preliberal; }
+        std::optional<int64_t> & get_mutable_preliberal() { return preliberal; }
+        void set_preliberal(const std::optional<int64_t> & value) { this->preliberal = value; }
+
+        const std::optional<int64_t> & get_prettifier() const { return prettifier; }
+        std::optional<int64_t> & get_mutable_prettifier() { return prettifier; }
+        void set_prettifier(const std::optional<int64_t> & value) { this->prettifier = value; }
+
+        const std::optional<int64_t> & get_rangework() const { return rangework; }
+        std::optional<int64_t> & get_mutable_rangework() { return rangework; }
+        void set_rangework(const std::optional<int64_t> & value) { this->rangework = value; }
+
+        const std::optional<int64_t> & get_redient() const { return redient; }
+        std::optional<int64_t> & get_mutable_redient() { return redient; }
+        void set_redient(const std::optional<int64_t> & value) { this->redient = value; }
+
+        const std::optional<int64_t> & get_subfusiform() const { return subfusiform; }
+        std::optional<int64_t> & get_mutable_subfusiform() { return subfusiform; }
+        void set_subfusiform(const std::optional<int64_t> & value) { this->subfusiform = value; }
+
+        const std::optional<int64_t> & get_suicidical() const { return suicidical; }
+        std::optional<int64_t> & get_mutable_suicidical() { return suicidical; }
+        void set_suicidical(const std::optional<int64_t> & value) { this->suicidical = value; }
+
+        const std::optional<int64_t> & get_swow() const { return swow; }
+        std::optional<int64_t> & get_mutable_swow() { return swow; }
+        void set_swow(const std::optional<int64_t> & value) { this->swow = value; }
+
+        const std::optional<int64_t> & get_wastrel() const { return wastrel; }
+        std::optional<int64_t> & get_mutable_wastrel() { return wastrel; }
+        void set_wastrel(const std::optional<int64_t> & value) { this->wastrel = value; }
+
+        const std::optional<int64_t> & get_wingle() const { return wingle; }
+        std::optional<int64_t> & get_mutable_wingle() { return wingle; }
+        void set_wingle(const std::optional<int64_t> & value) { this->wingle = value; }
+    };
+
+    using DiscordiaElement = std::variant<std::vector<int64_t>, DiscordiaClass>;
+
+    using Endomyce = std::variant<int64_t, std::string>;
+
+    using Epinephelidae = std::variant<bool, int64_t, std::string>;
+
+    using Eupatorium = std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>>;
+
+    class GryphosaurusClass {
+        public:
+        GryphosaurusClass() = default;
+        virtual ~GryphosaurusClass() = default;
+
+        private:
+        nlohmann::json amissibility;
+        nlohmann::json burushaski;
+        nlohmann::json citronin;
+        nlohmann::json coplaintiff;
+        nlohmann::json disquisitionary;
+        nlohmann::json enoplan;
+        nlohmann::json faintness;
+        nlohmann::json hebetomy;
+        nlohmann::json islandry;
+        nlohmann::json lameduck;
+        nlohmann::json overbattle;
+        nlohmann::json overinterested;
+        nlohmann::json phrenologic;
+        nlohmann::json rainband;
+        nlohmann::json shiningly;
+        nlohmann::json stamineous;
+        nlohmann::json subscapularis;
+        nlohmann::json tahami;
+        nlohmann::json undaubed;
+        nlohmann::json underntime;
+
+        public:
+        const nlohmann::json & get_amissibility() const { return amissibility; }
+        nlohmann::json & get_mutable_amissibility() { return amissibility; }
+        void set_amissibility(const nlohmann::json & value) { this->amissibility = value; }
+
+        const nlohmann::json & get_burushaski() const { return burushaski; }
+        nlohmann::json & get_mutable_burushaski() { return burushaski; }
+        void set_burushaski(const nlohmann::json & value) { this->burushaski = value; }
+
+        const nlohmann::json & get_citronin() const { return citronin; }
+        nlohmann::json & get_mutable_citronin() { return citronin; }
+        void set_citronin(const nlohmann::json & value) { this->citronin = value; }
+
+        const nlohmann::json & get_coplaintiff() const { return coplaintiff; }
+        nlohmann::json & get_mutable_coplaintiff() { return coplaintiff; }
+        void set_coplaintiff(const nlohmann::json & value) { this->coplaintiff = value; }
+
+        const nlohmann::json & get_disquisitionary() const { return disquisitionary; }
+        nlohmann::json & get_mutable_disquisitionary() { return disquisitionary; }
+        void set_disquisitionary(const nlohmann::json & value) { this->disquisitionary = value; }
+
+        const nlohmann::json & get_enoplan() const { return enoplan; }
+        nlohmann::json & get_mutable_enoplan() { return enoplan; }
+        void set_enoplan(const nlohmann::json & value) { this->enoplan = value; }
+
+        const nlohmann::json & get_faintness() const { return faintness; }
+        nlohmann::json & get_mutable_faintness() { return faintness; }
+        void set_faintness(const nlohmann::json & value) { this->faintness = value; }
+
+        const nlohmann::json & get_hebetomy() const { return hebetomy; }
+        nlohmann::json & get_mutable_hebetomy() { return hebetomy; }
+        void set_hebetomy(const nlohmann::json & value) { this->hebetomy = value; }
+
+        const nlohmann::json & get_islandry() const { return islandry; }
+        nlohmann::json & get_mutable_islandry() { return islandry; }
+        void set_islandry(const nlohmann::json & value) { this->islandry = value; }
+
+        const nlohmann::json & get_lameduck() const { return lameduck; }
+        nlohmann::json & get_mutable_lameduck() { return lameduck; }
+        void set_lameduck(const nlohmann::json & value) { this->lameduck = value; }
+
+        const nlohmann::json & get_overbattle() const { return overbattle; }
+        nlohmann::json & get_mutable_overbattle() { return overbattle; }
+        void set_overbattle(const nlohmann::json & value) { this->overbattle = value; }
+
+        const nlohmann::json & get_overinterested() const { return overinterested; }
+        nlohmann::json & get_mutable_overinterested() { return overinterested; }
+        void set_overinterested(const nlohmann::json & value) { this->overinterested = value; }
+
+        const nlohmann::json & get_phrenologic() const { return phrenologic; }
+        nlohmann::json & get_mutable_phrenologic() { return phrenologic; }
+        void set_phrenologic(const nlohmann::json & value) { this->phrenologic = value; }
+
+        const nlohmann::json & get_rainband() const { return rainband; }
+        nlohmann::json & get_mutable_rainband() { return rainband; }
+        void set_rainband(const nlohmann::json & value) { this->rainband = value; }
+
+        const nlohmann::json & get_shiningly() const { return shiningly; }
+        nlohmann::json & get_mutable_shiningly() { return shiningly; }
+        void set_shiningly(const nlohmann::json & value) { this->shiningly = value; }
+
+        const nlohmann::json & get_stamineous() const { return stamineous; }
+        nlohmann::json & get_mutable_stamineous() { return stamineous; }
+        void set_stamineous(const nlohmann::json & value) { this->stamineous = value; }
+
+        const nlohmann::json & get_subscapularis() const { return subscapularis; }
+        nlohmann::json & get_mutable_subscapularis() { return subscapularis; }
+        void set_subscapularis(const nlohmann::json & value) { this->subscapularis = value; }
+
+        const nlohmann::json & get_tahami() const { return tahami; }
+        nlohmann::json & get_mutable_tahami() { return tahami; }
+        void set_tahami(const nlohmann::json & value) { this->tahami = value; }
+
+        const nlohmann::json & get_undaubed() const { return undaubed; }
+        nlohmann::json & get_mutable_undaubed() { return undaubed; }
+        void set_undaubed(const nlohmann::json & value) { this->undaubed = value; }
+
+        const nlohmann::json & get_underntime() const { return underntime; }
+        nlohmann::json & get_mutable_underntime() { return underntime; }
+        void set_underntime(const nlohmann::json & value) { this->underntime = value; }
+    };
+
+    using GryphosaurusElement = std::variant<std::vector<int64_t>, GryphosaurusClass, std::string>;
+
+    using Koryak = std::variant<std::map<std::string, std::optional<int64_t>>, std::string>;
+
+    class LaviniaClass {
+        public:
+        LaviniaClass() = default;
+        virtual ~LaviniaClass() = default;
+
+        private:
+        std::optional<int64_t> agitable;
+        std::optional<int64_t> asininity;
+        std::optional<int64_t> benefiter;
+        std::optional<int64_t> bronzelike;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> cholesteatomatous;
+        std::optional<int64_t> deprivement;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> flippantness;
+        std::optional<int64_t> fogproof;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> merrymeeting;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> overcareful;
+        std::optional<int64_t> panaris;
+        std::optional<int64_t> preacceptance;
+        std::optional<int64_t> quinoxaline;
+        std::optional<int64_t> sig;
+        std::optional<int64_t> superconfusion;
+        std::optional<int64_t> tacana;
+        std::optional<int64_t> tillotter;
+        std::optional<int64_t> tranquillize;
+        std::optional<int64_t> unquestionable;
+        std::optional<int64_t> uproute;
+
+        public:
+        const std::optional<int64_t> & get_agitable() const { return agitable; }
+        std::optional<int64_t> & get_mutable_agitable() { return agitable; }
+        void set_agitable(const std::optional<int64_t> & value) { this->agitable = value; }
+
+        const std::optional<int64_t> & get_asininity() const { return asininity; }
+        std::optional<int64_t> & get_mutable_asininity() { return asininity; }
+        void set_asininity(const std::optional<int64_t> & value) { this->asininity = value; }
+
+        const std::optional<int64_t> & get_benefiter() const { return benefiter; }
+        std::optional<int64_t> & get_mutable_benefiter() { return benefiter; }
+        void set_benefiter(const std::optional<int64_t> & value) { this->benefiter = value; }
+
+        const std::optional<int64_t> & get_bronzelike() const { return bronzelike; }
+        std::optional<int64_t> & get_mutable_bronzelike() { return bronzelike; }
+        void set_bronzelike(const std::optional<int64_t> & value) { this->bronzelike = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_cholesteatomatous() const { return cholesteatomatous; }
+        std::optional<int64_t> & get_mutable_cholesteatomatous() { return cholesteatomatous; }
+        void set_cholesteatomatous(const std::optional<int64_t> & value) { this->cholesteatomatous = value; }
+
+        const std::optional<int64_t> & get_deprivement() const { return deprivement; }
+        std::optional<int64_t> & get_mutable_deprivement() { return deprivement; }
+        void set_deprivement(const std::optional<int64_t> & value) { this->deprivement = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_flippantness() const { return flippantness; }
+        std::optional<int64_t> & get_mutable_flippantness() { return flippantness; }
+        void set_flippantness(const std::optional<int64_t> & value) { this->flippantness = value; }
+
+        const std::optional<int64_t> & get_fogproof() const { return fogproof; }
+        std::optional<int64_t> & get_mutable_fogproof() { return fogproof; }
+        void set_fogproof(const std::optional<int64_t> & value) { this->fogproof = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_merrymeeting() const { return merrymeeting; }
+        std::optional<int64_t> & get_mutable_merrymeeting() { return merrymeeting; }
+        void set_merrymeeting(const std::optional<int64_t> & value) { this->merrymeeting = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_overcareful() const { return overcareful; }
+        std::optional<int64_t> & get_mutable_overcareful() { return overcareful; }
+        void set_overcareful(const std::optional<int64_t> & value) { this->overcareful = value; }
+
+        const std::optional<int64_t> & get_panaris() const { return panaris; }
+        std::optional<int64_t> & get_mutable_panaris() { return panaris; }
+        void set_panaris(const std::optional<int64_t> & value) { this->panaris = value; }
+
+        const std::optional<int64_t> & get_preacceptance() const { return preacceptance; }
+        std::optional<int64_t> & get_mutable_preacceptance() { return preacceptance; }
+        void set_preacceptance(const std::optional<int64_t> & value) { this->preacceptance = value; }
+
+        const std::optional<int64_t> & get_quinoxaline() const { return quinoxaline; }
+        std::optional<int64_t> & get_mutable_quinoxaline() { return quinoxaline; }
+        void set_quinoxaline(const std::optional<int64_t> & value) { this->quinoxaline = value; }
+
+        const std::optional<int64_t> & get_sig() const { return sig; }
+        std::optional<int64_t> & get_mutable_sig() { return sig; }
+        void set_sig(const std::optional<int64_t> & value) { this->sig = value; }
+
+        const std::optional<int64_t> & get_superconfusion() const { return superconfusion; }
+        std::optional<int64_t> & get_mutable_superconfusion() { return superconfusion; }
+        void set_superconfusion(const std::optional<int64_t> & value) { this->superconfusion = value; }
+
+        const std::optional<int64_t> & get_tacana() const { return tacana; }
+        std::optional<int64_t> & get_mutable_tacana() { return tacana; }
+        void set_tacana(const std::optional<int64_t> & value) { this->tacana = value; }
+
+        const std::optional<int64_t> & get_tillotter() const { return tillotter; }
+        std::optional<int64_t> & get_mutable_tillotter() { return tillotter; }
+        void set_tillotter(const std::optional<int64_t> & value) { this->tillotter = value; }
+
+        const std::optional<int64_t> & get_tranquillize() const { return tranquillize; }
+        std::optional<int64_t> & get_mutable_tranquillize() { return tranquillize; }
+        void set_tranquillize(const std::optional<int64_t> & value) { this->tranquillize = value; }
+
+        const std::optional<int64_t> & get_unquestionable() const { return unquestionable; }
+        std::optional<int64_t> & get_mutable_unquestionable() { return unquestionable; }
+        void set_unquestionable(const std::optional<int64_t> & value) { this->unquestionable = value; }
+
+        const std::optional<int64_t> & get_uproute() const { return uproute; }
+        std::optional<int64_t> & get_mutable_uproute() { return uproute; }
+        void set_uproute(const std::optional<int64_t> & value) { this->uproute = value; }
+    };
+
+    using LaviniaElement = std::variant<LaviniaClass, std::string>;
+
+    class OskarClass {
+        public:
+        OskarClass() = default;
+        virtual ~OskarClass() = default;
+
+        private:
+        nlohmann::json acrobates;
+        nlohmann::json beanshooter;
+        nlohmann::json bearhound;
+        nlohmann::json cayuga;
+        nlohmann::json guarneri;
+        nlohmann::json hypochondriacism;
+        nlohmann::json indication;
+        nlohmann::json jaculative;
+        nlohmann::json nagana;
+        nlohmann::json netherlandish;
+        nlohmann::json noctivagous;
+        nlohmann::json nonphysiological;
+        nlohmann::json praxis;
+        nlohmann::json provision;
+        nlohmann::json subterhuman;
+        nlohmann::json sunlit;
+        nlohmann::json syncraniate;
+        nlohmann::json teachment;
+        nlohmann::json unmutinous;
+        nlohmann::json unstoppable;
+
+        public:
+        const nlohmann::json & get_acrobates() const { return acrobates; }
+        nlohmann::json & get_mutable_acrobates() { return acrobates; }
+        void set_acrobates(const nlohmann::json & value) { this->acrobates = value; }
+
+        const nlohmann::json & get_beanshooter() const { return beanshooter; }
+        nlohmann::json & get_mutable_beanshooter() { return beanshooter; }
+        void set_beanshooter(const nlohmann::json & value) { this->beanshooter = value; }
+
+        const nlohmann::json & get_bearhound() const { return bearhound; }
+        nlohmann::json & get_mutable_bearhound() { return bearhound; }
+        void set_bearhound(const nlohmann::json & value) { this->bearhound = value; }
+
+        const nlohmann::json & get_cayuga() const { return cayuga; }
+        nlohmann::json & get_mutable_cayuga() { return cayuga; }
+        void set_cayuga(const nlohmann::json & value) { this->cayuga = value; }
+
+        const nlohmann::json & get_guarneri() const { return guarneri; }
+        nlohmann::json & get_mutable_guarneri() { return guarneri; }
+        void set_guarneri(const nlohmann::json & value) { this->guarneri = value; }
+
+        const nlohmann::json & get_hypochondriacism() const { return hypochondriacism; }
+        nlohmann::json & get_mutable_hypochondriacism() { return hypochondriacism; }
+        void set_hypochondriacism(const nlohmann::json & value) { this->hypochondriacism = value; }
+
+        const nlohmann::json & get_indication() const { return indication; }
+        nlohmann::json & get_mutable_indication() { return indication; }
+        void set_indication(const nlohmann::json & value) { this->indication = value; }
+
+        const nlohmann::json & get_jaculative() const { return jaculative; }
+        nlohmann::json & get_mutable_jaculative() { return jaculative; }
+        void set_jaculative(const nlohmann::json & value) { this->jaculative = value; }
+
+        const nlohmann::json & get_nagana() const { return nagana; }
+        nlohmann::json & get_mutable_nagana() { return nagana; }
+        void set_nagana(const nlohmann::json & value) { this->nagana = value; }
+
+        const nlohmann::json & get_netherlandish() const { return netherlandish; }
+        nlohmann::json & get_mutable_netherlandish() { return netherlandish; }
+        void set_netherlandish(const nlohmann::json & value) { this->netherlandish = value; }
+
+        const nlohmann::json & get_noctivagous() const { return noctivagous; }
+        nlohmann::json & get_mutable_noctivagous() { return noctivagous; }
+        void set_noctivagous(const nlohmann::json & value) { this->noctivagous = value; }
+
+        const nlohmann::json & get_nonphysiological() const { return nonphysiological; }
+        nlohmann::json & get_mutable_nonphysiological() { return nonphysiological; }
+        void set_nonphysiological(const nlohmann::json & value) { this->nonphysiological = value; }
+
+        const nlohmann::json & get_praxis() const { return praxis; }
+        nlohmann::json & get_mutable_praxis() { return praxis; }
+        void set_praxis(const nlohmann::json & value) { this->praxis = value; }
+
+        const nlohmann::json & get_provision() const { return provision; }
+        nlohmann::json & get_mutable_provision() { return provision; }
+        void set_provision(const nlohmann::json & value) { this->provision = value; }
+
+        const nlohmann::json & get_subterhuman() const { return subterhuman; }
+        nlohmann::json & get_mutable_subterhuman() { return subterhuman; }
+        void set_subterhuman(const nlohmann::json & value) { this->subterhuman = value; }
+
+        const nlohmann::json & get_sunlit() const { return sunlit; }
+        nlohmann::json & get_mutable_sunlit() { return sunlit; }
+        void set_sunlit(const nlohmann::json & value) { this->sunlit = value; }
+
+        const nlohmann::json & get_syncraniate() const { return syncraniate; }
+        nlohmann::json & get_mutable_syncraniate() { return syncraniate; }
+        void set_syncraniate(const nlohmann::json & value) { this->syncraniate = value; }
+
+        const nlohmann::json & get_teachment() const { return teachment; }
+        nlohmann::json & get_mutable_teachment() { return teachment; }
+        void set_teachment(const nlohmann::json & value) { this->teachment = value; }
+
+        const nlohmann::json & get_unmutinous() const { return unmutinous; }
+        nlohmann::json & get_mutable_unmutinous() { return unmutinous; }
+        void set_unmutinous(const nlohmann::json & value) { this->unmutinous = value; }
+
+        const nlohmann::json & get_unstoppable() const { return unstoppable; }
+        nlohmann::json & get_mutable_unstoppable() { return unstoppable; }
+        void set_unstoppable(const nlohmann::json & value) { this->unstoppable = value; }
+    };
+
+    using OskarElement = std::variant<std::vector<int64_t>, OskarClass>;
+
+    using RebeccaElement = std::variant<Rebecca, int64_t, std::string>;
+
+    using Rhomboganoidei = std::variant<std::vector<int64_t>, Rebecca, std::string>;
+
+    using Ruellia = std::variant<bool, Rebecca, std::string>;
+
+    using School = std::optional<std::variant<int64_t, std::map<std::string, int64_t>>>;
+
+    using Shakespearolater = std::variant<std::vector<int64_t>, double, std::string>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::vector<Abranchiata> abranchiata;
+        std::vector<Academe> academe;
+        std::vector<Acquirable> acquirable;
+        std::vector<Aerometry> aerometry;
+        std::vector<Alexin> alexin;
+        std::vector<AlleviateElement> alleviate;
+        std::vector<Amaa> amaas;
+        std::vector<Ambassage> ambassage;
+        std::vector<std::optional<Amphithyron>> amphithyron;
+        std::vector<std::optional<std::string>> andriana;
+        std::vector<AnkeeElement> ankee;
+        std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> annihilator;
+        nlohmann::json annulose;
+        std::vector<AnsarieElement> ansarie;
+        std::vector<Aphasia> aphasia;
+        std::vector<Asprawl> asprawl;
+        std::vector<std::optional<bool>> attractive;
+        std::map<std::string, int64_t> barksome;
+        std::vector<Bedesman> bedesman;
+        std::vector<Belard> belard;
+        std::vector<Bocking> bocking;
+        std::vector<Brawlingly> brawlingly;
+        std::vector<Brookie> brookie;
+        std::vector<Bumboatman> bumboatman;
+        std::vector<nlohmann::json> bystreet;
+        std::vector<Calaverite> calaverite;
+        std::vector<Catallactic> catallactic;
+        std::vector<Cemental> cemental;
+        std::vector<ChytridiaceaeElement> chytridiaceae;
+        std::vector<DiscordiaElement> discordia;
+        std::vector<Endomyce> endomyces;
+        std::vector<Epinephelidae> epinephelidae;
+        std::vector<Eupatorium> eupatorium;
+        std::vector<GryphosaurusElement> gryphosaurus;
+        std::vector<Koryak> koryak;
+        std::vector<LaviniaElement> lavinia;
+        std::vector<OskarElement> oskar;
+        std::vector<RebeccaElement> rebecca;
+        std::vector<Rhomboganoidei> rhomboganoidei;
+        bool rigsmal;
+        std::vector<Ruellia> ruellia;
+        std::vector<School> school;
+        std::vector<Shakespearolater> shakespearolater;
+        std::vector<double> svan;
+        std::map<std::string, double> wayao;
+
+        public:
+        const std::vector<Abranchiata> & get_abranchiata() const { return abranchiata; }
+        std::vector<Abranchiata> & get_mutable_abranchiata() { return abranchiata; }
+        void set_abranchiata(const std::vector<Abranchiata> & value) { this->abranchiata = value; }
+
+        const std::vector<Academe> & get_academe() const { return academe; }
+        std::vector<Academe> & get_mutable_academe() { return academe; }
+        void set_academe(const std::vector<Academe> & value) { this->academe = value; }
+
+        const std::vector<Acquirable> & get_acquirable() const { return acquirable; }
+        std::vector<Acquirable> & get_mutable_acquirable() { return acquirable; }
+        void set_acquirable(const std::vector<Acquirable> & value) { this->acquirable = value; }
+
+        const std::vector<Aerometry> & get_aerometry() const { return aerometry; }
+        std::vector<Aerometry> & get_mutable_aerometry() { return aerometry; }
+        void set_aerometry(const std::vector<Aerometry> & value) { this->aerometry = value; }
+
+        const std::vector<Alexin> & get_alexin() const { return alexin; }
+        std::vector<Alexin> & get_mutable_alexin() { return alexin; }
+        void set_alexin(const std::vector<Alexin> & value) { this->alexin = value; }
+
+        const std::vector<AlleviateElement> & get_alleviate() const { return alleviate; }
+        std::vector<AlleviateElement> & get_mutable_alleviate() { return alleviate; }
+        void set_alleviate(const std::vector<AlleviateElement> & value) { this->alleviate = value; }
+
+        const std::vector<Amaa> & get_amaas() const { return amaas; }
+        std::vector<Amaa> & get_mutable_amaas() { return amaas; }
+        void set_amaas(const std::vector<Amaa> & value) { this->amaas = value; }
+
+        const std::vector<Ambassage> & get_ambassage() const { return ambassage; }
+        std::vector<Ambassage> & get_mutable_ambassage() { return ambassage; }
+        void set_ambassage(const std::vector<Ambassage> & value) { this->ambassage = value; }
+
+        const std::vector<std::optional<Amphithyron>> & get_amphithyron() const { return amphithyron; }
+        std::vector<std::optional<Amphithyron>> & get_mutable_amphithyron() { return amphithyron; }
+        void set_amphithyron(const std::vector<std::optional<Amphithyron>> & value) { this->amphithyron = value; }
+
+        const std::vector<std::optional<std::string>> & get_andriana() const { return andriana; }
+        std::vector<std::optional<std::string>> & get_mutable_andriana() { return andriana; }
+        void set_andriana(const std::vector<std::optional<std::string>> & value) { this->andriana = value; }
+
+        const std::vector<AnkeeElement> & get_ankee() const { return ankee; }
+        std::vector<AnkeeElement> & get_mutable_ankee() { return ankee; }
+        void set_ankee(const std::vector<AnkeeElement> & value) { this->ankee = value; }
+
+        const std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> & get_annihilator() const { return annihilator; }
+        std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> & get_mutable_annihilator() { return annihilator; }
+        void set_annihilator(const std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>> & value) { this->annihilator = value; }
+
+        const nlohmann::json & get_annulose() const { return annulose; }
+        nlohmann::json & get_mutable_annulose() { return annulose; }
+        void set_annulose(const nlohmann::json & value) { this->annulose = value; }
+
+        const std::vector<AnsarieElement> & get_ansarie() const { return ansarie; }
+        std::vector<AnsarieElement> & get_mutable_ansarie() { return ansarie; }
+        void set_ansarie(const std::vector<AnsarieElement> & value) { this->ansarie = value; }
+
+        const std::vector<Aphasia> & get_aphasia() const { return aphasia; }
+        std::vector<Aphasia> & get_mutable_aphasia() { return aphasia; }
+        void set_aphasia(const std::vector<Aphasia> & value) { this->aphasia = value; }
+
+        const std::vector<Asprawl> & get_asprawl() const { return asprawl; }
+        std::vector<Asprawl> & get_mutable_asprawl() { return asprawl; }
+        void set_asprawl(const std::vector<Asprawl> & value) { this->asprawl = value; }
+
+        const std::vector<std::optional<bool>> & get_attractive() const { return attractive; }
+        std::vector<std::optional<bool>> & get_mutable_attractive() { return attractive; }
+        void set_attractive(const std::vector<std::optional<bool>> & value) { this->attractive = value; }
+
+        const std::map<std::string, int64_t> & get_barksome() const { return barksome; }
+        std::map<std::string, int64_t> & get_mutable_barksome() { return barksome; }
+        void set_barksome(const std::map<std::string, int64_t> & value) { this->barksome = value; }
+
+        const std::vector<Bedesman> & get_bedesman() const { return bedesman; }
+        std::vector<Bedesman> & get_mutable_bedesman() { return bedesman; }
+        void set_bedesman(const std::vector<Bedesman> & value) { this->bedesman = value; }
+
+        const std::vector<Belard> & get_belard() const { return belard; }
+        std::vector<Belard> & get_mutable_belard() { return belard; }
+        void set_belard(const std::vector<Belard> & value) { this->belard = value; }
+
+        const std::vector<Bocking> & get_bocking() const { return bocking; }
+        std::vector<Bocking> & get_mutable_bocking() { return bocking; }
+        void set_bocking(const std::vector<Bocking> & value) { this->bocking = value; }
+
+        const std::vector<Brawlingly> & get_brawlingly() const { return brawlingly; }
+        std::vector<Brawlingly> & get_mutable_brawlingly() { return brawlingly; }
+        void set_brawlingly(const std::vector<Brawlingly> & value) { this->brawlingly = value; }
+
+        const std::vector<Brookie> & get_brookie() const { return brookie; }
+        std::vector<Brookie> & get_mutable_brookie() { return brookie; }
+        void set_brookie(const std::vector<Brookie> & value) { this->brookie = value; }
+
+        const std::vector<Bumboatman> & get_bumboatman() const { return bumboatman; }
+        std::vector<Bumboatman> & get_mutable_bumboatman() { return bumboatman; }
+        void set_bumboatman(const std::vector<Bumboatman> & value) { this->bumboatman = value; }
+
+        const std::vector<nlohmann::json> & get_bystreet() const { return bystreet; }
+        std::vector<nlohmann::json> & get_mutable_bystreet() { return bystreet; }
+        void set_bystreet(const std::vector<nlohmann::json> & value) { this->bystreet = value; }
+
+        const std::vector<Calaverite> & get_calaverite() const { return calaverite; }
+        std::vector<Calaverite> & get_mutable_calaverite() { return calaverite; }
+        void set_calaverite(const std::vector<Calaverite> & value) { this->calaverite = value; }
+
+        const std::vector<Catallactic> & get_catallactic() const { return catallactic; }
+        std::vector<Catallactic> & get_mutable_catallactic() { return catallactic; }
+        void set_catallactic(const std::vector<Catallactic> & value) { this->catallactic = value; }
+
+        const std::vector<Cemental> & get_cemental() const { return cemental; }
+        std::vector<Cemental> & get_mutable_cemental() { return cemental; }
+        void set_cemental(const std::vector<Cemental> & value) { this->cemental = value; }
+
+        const std::vector<ChytridiaceaeElement> & get_chytridiaceae() const { return chytridiaceae; }
+        std::vector<ChytridiaceaeElement> & get_mutable_chytridiaceae() { return chytridiaceae; }
+        void set_chytridiaceae(const std::vector<ChytridiaceaeElement> & value) { this->chytridiaceae = value; }
+
+        const std::vector<DiscordiaElement> & get_discordia() const { return discordia; }
+        std::vector<DiscordiaElement> & get_mutable_discordia() { return discordia; }
+        void set_discordia(const std::vector<DiscordiaElement> & value) { this->discordia = value; }
+
+        const std::vector<Endomyce> & get_endomyces() const { return endomyces; }
+        std::vector<Endomyce> & get_mutable_endomyces() { return endomyces; }
+        void set_endomyces(const std::vector<Endomyce> & value) { this->endomyces = value; }
+
+        const std::vector<Epinephelidae> & get_epinephelidae() const { return epinephelidae; }
+        std::vector<Epinephelidae> & get_mutable_epinephelidae() { return epinephelidae; }
+        void set_epinephelidae(const std::vector<Epinephelidae> & value) { this->epinephelidae = value; }
+
+        const std::vector<Eupatorium> & get_eupatorium() const { return eupatorium; }
+        std::vector<Eupatorium> & get_mutable_eupatorium() { return eupatorium; }
+        void set_eupatorium(const std::vector<Eupatorium> & value) { this->eupatorium = value; }
+
+        const std::vector<GryphosaurusElement> & get_gryphosaurus() const { return gryphosaurus; }
+        std::vector<GryphosaurusElement> & get_mutable_gryphosaurus() { return gryphosaurus; }
+        void set_gryphosaurus(const std::vector<GryphosaurusElement> & value) { this->gryphosaurus = value; }
+
+        const std::vector<Koryak> & get_koryak() const { return koryak; }
+        std::vector<Koryak> & get_mutable_koryak() { return koryak; }
+        void set_koryak(const std::vector<Koryak> & value) { this->koryak = value; }
+
+        const std::vector<LaviniaElement> & get_lavinia() const { return lavinia; }
+        std::vector<LaviniaElement> & get_mutable_lavinia() { return lavinia; }
+        void set_lavinia(const std::vector<LaviniaElement> & value) { this->lavinia = value; }
+
+        const std::vector<OskarElement> & get_oskar() const { return oskar; }
+        std::vector<OskarElement> & get_mutable_oskar() { return oskar; }
+        void set_oskar(const std::vector<OskarElement> & value) { this->oskar = value; }
+
+        const std::vector<RebeccaElement> & get_rebecca() const { return rebecca; }
+        std::vector<RebeccaElement> & get_mutable_rebecca() { return rebecca; }
+        void set_rebecca(const std::vector<RebeccaElement> & value) { this->rebecca = value; }
+
+        const std::vector<Rhomboganoidei> & get_rhomboganoidei() const { return rhomboganoidei; }
+        std::vector<Rhomboganoidei> & get_mutable_rhomboganoidei() { return rhomboganoidei; }
+        void set_rhomboganoidei(const std::vector<Rhomboganoidei> & value) { this->rhomboganoidei = value; }
+
+        const bool & get_rigsmal() const { return rigsmal; }
+        bool & get_mutable_rigsmal() { return rigsmal; }
+        void set_rigsmal(const bool & value) { this->rigsmal = value; }
+
+        const std::vector<Ruellia> & get_ruellia() const { return ruellia; }
+        std::vector<Ruellia> & get_mutable_ruellia() { return ruellia; }
+        void set_ruellia(const std::vector<Ruellia> & value) { this->ruellia = value; }
+
+        const std::vector<School> & get_school() const { return school; }
+        std::vector<School> & get_mutable_school() { return school; }
+        void set_school(const std::vector<School> & value) { this->school = value; }
+
+        const std::vector<Shakespearolater> & get_shakespearolater() const { return shakespearolater; }
+        std::vector<Shakespearolater> & get_mutable_shakespearolater() { return shakespearolater; }
+        void set_shakespearolater(const std::vector<Shakespearolater> & value) { this->shakespearolater = value; }
+
+        const std::vector<double> & get_svan() const { return svan; }
+        std::vector<double> & get_mutable_svan() { return svan; }
+        void set_svan(const std::vector<double> & value) { this->svan = value; }
+
+        const std::map<std::string, double> & get_wayao() const { return wayao; }
+        std::map<std::string, double> & get_mutable_wayao() { return wayao; }
+        void set_wayao(const std::map<std::string, double> & value) { this->wayao = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, AlleviateClass & x);
+void to_json(json & j, const AlleviateClass & x);
+
+void from_json(const json & j, Rebecca & x);
+void to_json(json & j, const Rebecca & x);
+
+void from_json(const json & j, Amphithyron & x);
+void to_json(json & j, const Amphithyron & x);
+
+void from_json(const json & j, AnkeeClass & x);
+void to_json(json & j, const AnkeeClass & x);
+
+void from_json(const json & j, AnsarieClass & x);
+void to_json(json & j, const AnsarieClass & x);
+
+void from_json(const json & j, ChytridiaceaeClass & x);
+void to_json(json & j, const ChytridiaceaeClass & x);
+
+void from_json(const json & j, DiscordiaClass & x);
+void to_json(json & j, const DiscordiaClass & x);
+
+void from_json(const json & j, GryphosaurusClass & x);
+void to_json(json & j, const GryphosaurusClass & x);
+
+void from_json(const json & j, LaviniaClass & x);
+void to_json(json & j, const LaviniaClass & x);
+
+void from_json(const json & j, OskarClass & x);
+void to_json(json & j, const OskarClass & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(const json & j, std::variant<bool, double> & x);
+    static void to_json(json & j, const std::variant<bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::Rebecca, int64_t> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::Rebecca, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double, std::string>> {
+    static void from_json(const json & j, std::variant<bool, double, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::ChytridiaceaeClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::ChytridiaceaeClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<bool, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>> {
+    static void from_json(const json & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LaviniaClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::LaviniaClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::LaviniaClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::OskarClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::Rebecca, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::Rebecca, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::Rebecca, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::Rebecca, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double, std::string> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, AlleviateClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apriori(get_untyped(j, "apriori"));
+        x.set_beggarer(get_untyped(j, "beggarer"));
+        x.set_brokenheartedly(get_untyped(j, "brokenheartedly"));
+        x.set_debilitation(get_untyped(j, "debilitation"));
+        x.set_frike(get_untyped(j, "frike"));
+        x.set_gastrolith(get_untyped(j, "gastrolith"));
+        x.set_hulsean(get_untyped(j, "Hulsean"));
+        x.set_orthocentric(get_untyped(j, "orthocentric"));
+        x.set_petaly(get_untyped(j, "petaly"));
+        x.set_probudgeting(get_untyped(j, "probudgeting"));
+        x.set_reacquire(get_untyped(j, "reacquire"));
+        x.set_scow(get_untyped(j, "scow"));
+        x.set_shutoff(get_untyped(j, "shutoff"));
+        x.set_subcontiguous(get_untyped(j, "subcontiguous"));
+        x.set_suffumigate(get_untyped(j, "suffumigate"));
+        x.set_transformable(get_untyped(j, "transformable"));
+        x.set_uncoroneted(get_untyped(j, "uncoroneted"));
+        x.set_unparking(get_untyped(j, "unparking"));
+        x.set_unvarnishedness(get_untyped(j, "unvarnishedness"));
+        x.set_wherewithal(get_untyped(j, "wherewithal"));
+    }
+
+    inline void to_json(json & j, const AlleviateClass & x) {
+        j = json::object();
+        j["apriori"] = x.get_apriori();
+        j["beggarer"] = x.get_beggarer();
+        j["brokenheartedly"] = x.get_brokenheartedly();
+        j["debilitation"] = x.get_debilitation();
+        j["frike"] = x.get_frike();
+        j["gastrolith"] = x.get_gastrolith();
+        j["Hulsean"] = x.get_hulsean();
+        j["orthocentric"] = x.get_orthocentric();
+        j["petaly"] = x.get_petaly();
+        j["probudgeting"] = x.get_probudgeting();
+        j["reacquire"] = x.get_reacquire();
+        j["scow"] = x.get_scow();
+        j["shutoff"] = x.get_shutoff();
+        j["subcontiguous"] = x.get_subcontiguous();
+        j["suffumigate"] = x.get_suffumigate();
+        j["transformable"] = x.get_transformable();
+        j["uncoroneted"] = x.get_uncoroneted();
+        j["unparking"] = x.get_unparking();
+        j["unvarnishedness"] = x.get_unvarnishedness();
+        j["wherewithal"] = x.get_wherewithal();
+    }
+
+    inline void from_json(const json & j, Rebecca& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, const Rebecca & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(const json & j, Amphithyron& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_akroasis(get_stack_optional<int64_t>(j, "akroasis"));
+        x.set_antiphonical(get_stack_optional<int64_t>(j, "antiphonical"));
+        x.set_basebred(get_stack_optional<int64_t>(j, "basebred"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_conductometric(get_stack_optional<int64_t>(j, "conductometric"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ensilation(get_stack_optional<int64_t>(j, "ensilation"));
+        x.set_eyebolt(get_stack_optional<int64_t>(j, "eyebolt"));
+        x.set_fistulated(get_stack_optional<int64_t>(j, "fistulated"));
+        x.set_heteropod(get_stack_optional<int64_t>(j, "heteropod"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_juniperus(get_stack_optional<int64_t>(j, "Juniperus"));
+        x.set_labyrinthically(get_stack_optional<int64_t>(j, "labyrinthically"));
+        x.set_martyrization(get_stack_optional<int64_t>(j, "martyrization"));
+        x.set_mispolicy(get_stack_optional<int64_t>(j, "mispolicy"));
+        x.set_multipara(get_stack_optional<int64_t>(j, "multipara"));
+        x.set_nazirite(get_stack_optional<int64_t>(j, "Nazirite"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_possessorial(get_stack_optional<int64_t>(j, "possessorial"));
+        x.set_shamed(get_stack_optional<int64_t>(j, "shamed"));
+        x.set_shelfworn(get_stack_optional<int64_t>(j, "shelfworn"));
+        x.set_stagnum(get_stack_optional<int64_t>(j, "stagnum"));
+        x.set_those(get_stack_optional<int64_t>(j, "Those"));
+        x.set_undecimal(get_stack_optional<int64_t>(j, "undecimal"));
+    }
+
+    inline void to_json(json & j, const Amphithyron & x) {
+        j = json::object();
+        j["akroasis"] = x.get_akroasis();
+        j["antiphonical"] = x.get_antiphonical();
+        j["basebred"] = x.get_basebred();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["conductometric"] = x.get_conductometric();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ensilation"] = x.get_ensilation();
+        j["eyebolt"] = x.get_eyebolt();
+        j["fistulated"] = x.get_fistulated();
+        j["heteropod"] = x.get_heteropod();
+        j["homocerc"] = x.get_homocerc();
+        j["Juniperus"] = x.get_juniperus();
+        j["labyrinthically"] = x.get_labyrinthically();
+        j["martyrization"] = x.get_martyrization();
+        j["mispolicy"] = x.get_mispolicy();
+        j["multipara"] = x.get_multipara();
+        j["Nazirite"] = x.get_nazirite();
+        j["nonbookish"] = x.get_nonbookish();
+        j["possessorial"] = x.get_possessorial();
+        j["shamed"] = x.get_shamed();
+        j["shelfworn"] = x.get_shelfworn();
+        j["stagnum"] = x.get_stagnum();
+        j["Those"] = x.get_those();
+        j["undecimal"] = x.get_undecimal();
+    }
+
+    inline void from_json(const json & j, AnkeeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_anomoean(get_untyped(j, "Anomoean"));
+        x.set_barleyhood(get_untyped(j, "barleyhood"));
+        x.set_befriender(get_untyped(j, "befriender"));
+        x.set_brutishness(get_untyped(j, "brutishness"));
+        x.set_cephalalgy(get_untyped(j, "cephalalgy"));
+        x.set_cirurgian(get_untyped(j, "cirurgian"));
+        x.set_conventionally(get_untyped(j, "conventionally"));
+        x.set_jackshay(get_untyped(j, "jackshay"));
+        x.set_milammeter(get_untyped(j, "milammeter"));
+        x.set_naja(get_untyped(j, "Naja"));
+        x.set_ombrological(get_untyped(j, "ombrological"));
+        x.set_phonasthenia(get_untyped(j, "phonasthenia"));
+        x.set_retrievableness(get_untyped(j, "retrievableness"));
+        x.set_snakily(get_untyped(j, "snakily"));
+        x.set_swot(get_untyped(j, "swot"));
+        x.set_tartlet(get_untyped(j, "tartlet"));
+        x.set_thiofuran(get_untyped(j, "thiofuran"));
+        x.set_tracheophone(get_untyped(j, "tracheophone"));
+        x.set_tuglike(get_untyped(j, "tuglike"));
+        x.set_unscratchingly(get_untyped(j, "unscratchingly"));
+    }
+
+    inline void to_json(json & j, const AnkeeClass & x) {
+        j = json::object();
+        j["Anomoean"] = x.get_anomoean();
+        j["barleyhood"] = x.get_barleyhood();
+        j["befriender"] = x.get_befriender();
+        j["brutishness"] = x.get_brutishness();
+        j["cephalalgy"] = x.get_cephalalgy();
+        j["cirurgian"] = x.get_cirurgian();
+        j["conventionally"] = x.get_conventionally();
+        j["jackshay"] = x.get_jackshay();
+        j["milammeter"] = x.get_milammeter();
+        j["Naja"] = x.get_naja();
+        j["ombrological"] = x.get_ombrological();
+        j["phonasthenia"] = x.get_phonasthenia();
+        j["retrievableness"] = x.get_retrievableness();
+        j["snakily"] = x.get_snakily();
+        j["swot"] = x.get_swot();
+        j["tartlet"] = x.get_tartlet();
+        j["thiofuran"] = x.get_thiofuran();
+        j["tracheophone"] = x.get_tracheophone();
+        j["tuglike"] = x.get_tuglike();
+        j["unscratchingly"] = x.get_unscratchingly();
+    }
+
+    inline void from_json(const json & j, AnsarieClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_accension(get_untyped(j, "accension"));
+        x.set_alida(get_untyped(j, "Alida"));
+        x.set_asteria(get_untyped(j, "asteria"));
+        x.set_beriberic(get_untyped(j, "beriberic"));
+        x.set_edgebone(get_untyped(j, "edgebone"));
+        x.set_gastrodialysis(get_untyped(j, "gastrodialysis"));
+        x.set_geographic(get_untyped(j, "geographic"));
+        x.set_ictonyx(get_untyped(j, "Ictonyx"));
+        x.set_metrocele(get_untyped(j, "metrocele"));
+        x.set_misgraft(get_untyped(j, "misgraft"));
+        x.set_monteith(get_untyped(j, "monteith"));
+        x.set_notcher(get_untyped(j, "notcher"));
+        x.set_prorestriction(get_untyped(j, "prorestriction"));
+        x.set_ramist(get_untyped(j, "Ramist"));
+        x.set_throatlet(get_untyped(j, "throatlet"));
+        x.set_unfair(get_untyped(j, "unfair"));
+        x.set_unsynonymous(get_untyped(j, "unsynonymous"));
+        x.set_water(get_untyped(j, "water"));
+        x.set_zestfully(get_untyped(j, "zestfully"));
+        x.set_zincic(get_untyped(j, "zincic"));
+    }
+
+    inline void to_json(json & j, const AnsarieClass & x) {
+        j = json::object();
+        j["accension"] = x.get_accension();
+        j["Alida"] = x.get_alida();
+        j["asteria"] = x.get_asteria();
+        j["beriberic"] = x.get_beriberic();
+        j["edgebone"] = x.get_edgebone();
+        j["gastrodialysis"] = x.get_gastrodialysis();
+        j["geographic"] = x.get_geographic();
+        j["Ictonyx"] = x.get_ictonyx();
+        j["metrocele"] = x.get_metrocele();
+        j["misgraft"] = x.get_misgraft();
+        j["monteith"] = x.get_monteith();
+        j["notcher"] = x.get_notcher();
+        j["prorestriction"] = x.get_prorestriction();
+        j["Ramist"] = x.get_ramist();
+        j["throatlet"] = x.get_throatlet();
+        j["unfair"] = x.get_unfair();
+        j["unsynonymous"] = x.get_unsynonymous();
+        j["water"] = x.get_water();
+        j["zestfully"] = x.get_zestfully();
+        j["zincic"] = x.get_zincic();
+    }
+
+    inline void from_json(const json & j, ChytridiaceaeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_batidaceae(get_untyped(j, "Batidaceae"));
+        x.set_brechites(get_untyped(j, "Brechites"));
+        x.set_codespairer(get_untyped(j, "codespairer"));
+        x.set_emery(get_untyped(j, "Emery"));
+        x.set_enervative(get_untyped(j, "enervative"));
+        x.set_excriminate(get_untyped(j, "excriminate"));
+        x.set_goshenite(get_untyped(j, "goshenite"));
+        x.set_grime(get_untyped(j, "grime"));
+        x.set_gritten(get_untyped(j, "gritten"));
+        x.set_hectorly(get_untyped(j, "hectorly"));
+        x.set_intermediation(get_untyped(j, "intermediation"));
+        x.set_meeterly(get_untyped(j, "meeterly"));
+        x.set_narraganset(get_untyped(j, "Narraganset"));
+        x.set_onymatic(get_untyped(j, "onymatic"));
+        x.set_paddlecock(get_untyped(j, "paddlecock"));
+        x.set_thana(get_untyped(j, "thana"));
+        x.set_thornily(get_untyped(j, "thornily"));
+        x.set_uckia(get_untyped(j, "uckia"));
+        x.set_unmettle(get_untyped(j, "unmettle"));
+        x.set_vorticellid(get_untyped(j, "vorticellid"));
+    }
+
+    inline void to_json(json & j, const ChytridiaceaeClass & x) {
+        j = json::object();
+        j["Batidaceae"] = x.get_batidaceae();
+        j["Brechites"] = x.get_brechites();
+        j["codespairer"] = x.get_codespairer();
+        j["Emery"] = x.get_emery();
+        j["enervative"] = x.get_enervative();
+        j["excriminate"] = x.get_excriminate();
+        j["goshenite"] = x.get_goshenite();
+        j["grime"] = x.get_grime();
+        j["gritten"] = x.get_gritten();
+        j["hectorly"] = x.get_hectorly();
+        j["intermediation"] = x.get_intermediation();
+        j["meeterly"] = x.get_meeterly();
+        j["Narraganset"] = x.get_narraganset();
+        j["onymatic"] = x.get_onymatic();
+        j["paddlecock"] = x.get_paddlecock();
+        j["thana"] = x.get_thana();
+        j["thornily"] = x.get_thornily();
+        j["uckia"] = x.get_uckia();
+        j["unmettle"] = x.get_unmettle();
+        j["vorticellid"] = x.get_vorticellid();
+    }
+
+    inline void from_json(const json & j, DiscordiaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_altaic(get_stack_optional<int64_t>(j, "Altaic"));
+        x.set_amoristic(get_stack_optional<int64_t>(j, "amoristic"));
+        x.set_blennophthalmia(get_stack_optional<int64_t>(j, "blennophthalmia"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disciplinability(get_stack_optional<int64_t>(j, "disciplinability"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_goofer(get_stack_optional<int64_t>(j, "goofer"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_laryngograph(get_stack_optional<int64_t>(j, "laryngograph"));
+        x.set_leucitis(get_stack_optional<int64_t>(j, "leucitis"));
+        x.set_lymphocyst(get_stack_optional<int64_t>(j, "lymphocyst"));
+        x.set_microcosmology(get_stack_optional<int64_t>(j, "microcosmology"));
+        x.set_nauseation(get_stack_optional<int64_t>(j, "nauseation"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_patarin(get_stack_optional<int64_t>(j, "Patarin"));
+        x.set_preliberal(get_stack_optional<int64_t>(j, "preliberal"));
+        x.set_prettifier(get_stack_optional<int64_t>(j, "prettifier"));
+        x.set_rangework(get_stack_optional<int64_t>(j, "rangework"));
+        x.set_redient(get_stack_optional<int64_t>(j, "redient"));
+        x.set_subfusiform(get_stack_optional<int64_t>(j, "subfusiform"));
+        x.set_suicidical(get_stack_optional<int64_t>(j, "suicidical"));
+        x.set_swow(get_stack_optional<int64_t>(j, "swow"));
+        x.set_wastrel(get_stack_optional<int64_t>(j, "wastrel"));
+        x.set_wingle(get_stack_optional<int64_t>(j, "wingle"));
+    }
+
+    inline void to_json(json & j, const DiscordiaClass & x) {
+        j = json::object();
+        j["Altaic"] = x.get_altaic();
+        j["amoristic"] = x.get_amoristic();
+        j["blennophthalmia"] = x.get_blennophthalmia();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disciplinability"] = x.get_disciplinability();
+        j["disdiapason"] = x.get_disdiapason();
+        j["goofer"] = x.get_goofer();
+        j["homocerc"] = x.get_homocerc();
+        j["laryngograph"] = x.get_laryngograph();
+        j["leucitis"] = x.get_leucitis();
+        j["lymphocyst"] = x.get_lymphocyst();
+        j["microcosmology"] = x.get_microcosmology();
+        j["nauseation"] = x.get_nauseation();
+        j["nonbookish"] = x.get_nonbookish();
+        j["Patarin"] = x.get_patarin();
+        j["preliberal"] = x.get_preliberal();
+        j["prettifier"] = x.get_prettifier();
+        j["rangework"] = x.get_rangework();
+        j["redient"] = x.get_redient();
+        j["subfusiform"] = x.get_subfusiform();
+        j["suicidical"] = x.get_suicidical();
+        j["swow"] = x.get_swow();
+        j["wastrel"] = x.get_wastrel();
+        j["wingle"] = x.get_wingle();
+    }
+
+    inline void from_json(const json & j, GryphosaurusClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amissibility(get_untyped(j, "amissibility"));
+        x.set_burushaski(get_untyped(j, "Burushaski"));
+        x.set_citronin(get_untyped(j, "citronin"));
+        x.set_coplaintiff(get_untyped(j, "coplaintiff"));
+        x.set_disquisitionary(get_untyped(j, "disquisitionary"));
+        x.set_enoplan(get_untyped(j, "enoplan"));
+        x.set_faintness(get_untyped(j, "faintness"));
+        x.set_hebetomy(get_untyped(j, "hebetomy"));
+        x.set_islandry(get_untyped(j, "islandry"));
+        x.set_lameduck(get_untyped(j, "lameduck"));
+        x.set_overbattle(get_untyped(j, "overbattle"));
+        x.set_overinterested(get_untyped(j, "overinterested"));
+        x.set_phrenologic(get_untyped(j, "phrenologic"));
+        x.set_rainband(get_untyped(j, "rainband"));
+        x.set_shiningly(get_untyped(j, "shiningly"));
+        x.set_stamineous(get_untyped(j, "stamineous"));
+        x.set_subscapularis(get_untyped(j, "subscapularis"));
+        x.set_tahami(get_untyped(j, "Tahami"));
+        x.set_undaubed(get_untyped(j, "undaubed"));
+        x.set_underntime(get_untyped(j, "underntime"));
+    }
+
+    inline void to_json(json & j, const GryphosaurusClass & x) {
+        j = json::object();
+        j["amissibility"] = x.get_amissibility();
+        j["Burushaski"] = x.get_burushaski();
+        j["citronin"] = x.get_citronin();
+        j["coplaintiff"] = x.get_coplaintiff();
+        j["disquisitionary"] = x.get_disquisitionary();
+        j["enoplan"] = x.get_enoplan();
+        j["faintness"] = x.get_faintness();
+        j["hebetomy"] = x.get_hebetomy();
+        j["islandry"] = x.get_islandry();
+        j["lameduck"] = x.get_lameduck();
+        j["overbattle"] = x.get_overbattle();
+        j["overinterested"] = x.get_overinterested();
+        j["phrenologic"] = x.get_phrenologic();
+        j["rainband"] = x.get_rainband();
+        j["shiningly"] = x.get_shiningly();
+        j["stamineous"] = x.get_stamineous();
+        j["subscapularis"] = x.get_subscapularis();
+        j["Tahami"] = x.get_tahami();
+        j["undaubed"] = x.get_undaubed();
+        j["underntime"] = x.get_underntime();
+    }
+
+    inline void from_json(const json & j, LaviniaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_agitable(get_stack_optional<int64_t>(j, "agitable"));
+        x.set_asininity(get_stack_optional<int64_t>(j, "asininity"));
+        x.set_benefiter(get_stack_optional<int64_t>(j, "benefiter"));
+        x.set_bronzelike(get_stack_optional<int64_t>(j, "bronzelike"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_cholesteatomatous(get_stack_optional<int64_t>(j, "cholesteatomatous"));
+        x.set_deprivement(get_stack_optional<int64_t>(j, "deprivement"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_flippantness(get_stack_optional<int64_t>(j, "flippantness"));
+        x.set_fogproof(get_stack_optional<int64_t>(j, "fogproof"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_merrymeeting(get_stack_optional<int64_t>(j, "merrymeeting"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_overcareful(get_stack_optional<int64_t>(j, "overcareful"));
+        x.set_panaris(get_stack_optional<int64_t>(j, "panaris"));
+        x.set_preacceptance(get_stack_optional<int64_t>(j, "preacceptance"));
+        x.set_quinoxaline(get_stack_optional<int64_t>(j, "quinoxaline"));
+        x.set_sig(get_stack_optional<int64_t>(j, "sig"));
+        x.set_superconfusion(get_stack_optional<int64_t>(j, "superconfusion"));
+        x.set_tacana(get_stack_optional<int64_t>(j, "Tacana"));
+        x.set_tillotter(get_stack_optional<int64_t>(j, "tillotter"));
+        x.set_tranquillize(get_stack_optional<int64_t>(j, "tranquillize"));
+        x.set_unquestionable(get_stack_optional<int64_t>(j, "unquestionable"));
+        x.set_uproute(get_stack_optional<int64_t>(j, "uproute"));
+    }
+
+    inline void to_json(json & j, const LaviniaClass & x) {
+        j = json::object();
+        j["agitable"] = x.get_agitable();
+        j["asininity"] = x.get_asininity();
+        j["benefiter"] = x.get_benefiter();
+        j["bronzelike"] = x.get_bronzelike();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["cholesteatomatous"] = x.get_cholesteatomatous();
+        j["deprivement"] = x.get_deprivement();
+        j["disdiapason"] = x.get_disdiapason();
+        j["flippantness"] = x.get_flippantness();
+        j["fogproof"] = x.get_fogproof();
+        j["homocerc"] = x.get_homocerc();
+        j["merrymeeting"] = x.get_merrymeeting();
+        j["nonbookish"] = x.get_nonbookish();
+        j["overcareful"] = x.get_overcareful();
+        j["panaris"] = x.get_panaris();
+        j["preacceptance"] = x.get_preacceptance();
+        j["quinoxaline"] = x.get_quinoxaline();
+        j["sig"] = x.get_sig();
+        j["superconfusion"] = x.get_superconfusion();
+        j["Tacana"] = x.get_tacana();
+        j["tillotter"] = x.get_tillotter();
+        j["tranquillize"] = x.get_tranquillize();
+        j["unquestionable"] = x.get_unquestionable();
+        j["uproute"] = x.get_uproute();
+    }
+
+    inline void from_json(const json & j, OskarClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acrobates(get_untyped(j, "Acrobates"));
+        x.set_beanshooter(get_untyped(j, "beanshooter"));
+        x.set_bearhound(get_untyped(j, "bearhound"));
+        x.set_cayuga(get_untyped(j, "Cayuga"));
+        x.set_guarneri(get_untyped(j, "guarneri"));
+        x.set_hypochondriacism(get_untyped(j, "hypochondriacism"));
+        x.set_indication(get_untyped(j, "indication"));
+        x.set_jaculative(get_untyped(j, "jaculative"));
+        x.set_nagana(get_untyped(j, "nagana"));
+        x.set_netherlandish(get_untyped(j, "Netherlandish"));
+        x.set_noctivagous(get_untyped(j, "noctivagous"));
+        x.set_nonphysiological(get_untyped(j, "nonphysiological"));
+        x.set_praxis(get_untyped(j, "praxis"));
+        x.set_provision(get_untyped(j, "provision"));
+        x.set_subterhuman(get_untyped(j, "subterhuman"));
+        x.set_sunlit(get_untyped(j, "sunlit"));
+        x.set_syncraniate(get_untyped(j, "syncraniate"));
+        x.set_teachment(get_untyped(j, "teachment"));
+        x.set_unmutinous(get_untyped(j, "unmutinous"));
+        x.set_unstoppable(get_untyped(j, "unstoppable"));
+    }
+
+    inline void to_json(json & j, const OskarClass & x) {
+        j = json::object();
+        j["Acrobates"] = x.get_acrobates();
+        j["beanshooter"] = x.get_beanshooter();
+        j["bearhound"] = x.get_bearhound();
+        j["Cayuga"] = x.get_cayuga();
+        j["guarneri"] = x.get_guarneri();
+        j["hypochondriacism"] = x.get_hypochondriacism();
+        j["indication"] = x.get_indication();
+        j["jaculative"] = x.get_jaculative();
+        j["nagana"] = x.get_nagana();
+        j["Netherlandish"] = x.get_netherlandish();
+        j["noctivagous"] = x.get_noctivagous();
+        j["nonphysiological"] = x.get_nonphysiological();
+        j["praxis"] = x.get_praxis();
+        j["provision"] = x.get_provision();
+        j["subterhuman"] = x.get_subterhuman();
+        j["sunlit"] = x.get_sunlit();
+        j["syncraniate"] = x.get_syncraniate();
+        j["teachment"] = x.get_teachment();
+        j["unmutinous"] = x.get_unmutinous();
+        j["unstoppable"] = x.get_unstoppable();
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_abranchiata(j.at("Abranchiata").get<std::vector<Abranchiata>>());
+        x.set_academe(j.at("academe").get<std::vector<Academe>>());
+        x.set_acquirable(j.at("acquirable").get<std::vector<Acquirable>>());
+        x.set_aerometry(j.at("aerometry").get<std::vector<Aerometry>>());
+        x.set_alexin(j.at("alexin").get<std::vector<Alexin>>());
+        x.set_alleviate(j.at("alleviate").get<std::vector<AlleviateElement>>());
+        x.set_amaas(j.at("amaas").get<std::vector<Amaa>>());
+        x.set_ambassage(j.at("ambassage").get<std::vector<Ambassage>>());
+        x.set_amphithyron(j.at("amphithyron").get<std::vector<std::optional<Amphithyron>>>());
+        x.set_andriana(j.at("Andriana").get<std::vector<std::optional<std::string>>>());
+        x.set_ankee(j.at("ankee").get<std::vector<AnkeeElement>>());
+        x.set_annihilator(j.at("annihilator").get<std::vector<std::optional<std::map<std::string, std::optional<int64_t>>>>>());
+        x.set_annulose(get_untyped(j, "annulose"));
+        x.set_ansarie(j.at("Ansarie").get<std::vector<AnsarieElement>>());
+        x.set_aphasia(j.at("aphasia").get<std::vector<Aphasia>>());
+        x.set_asprawl(j.at("asprawl").get<std::vector<Asprawl>>());
+        x.set_attractive(j.at("attractive").get<std::vector<std::optional<bool>>>());
+        x.set_barksome(j.at("barksome").get<std::map<std::string, int64_t>>());
+        x.set_bedesman(j.at("bedesman").get<std::vector<Bedesman>>());
+        x.set_belard(j.at("belard").get<std::vector<Belard>>());
+        x.set_bocking(j.at("bocking").get<std::vector<Bocking>>());
+        x.set_brawlingly(j.at("brawlingly").get<std::vector<Brawlingly>>());
+        x.set_brookie(j.at("brookie").get<std::vector<Brookie>>());
+        x.set_bumboatman(j.at("bumboatman").get<std::vector<Bumboatman>>());
+        x.set_bystreet(j.at("bystreet").get<std::vector<nlohmann::json>>());
+        x.set_calaverite(j.at("calaverite").get<std::vector<Calaverite>>());
+        x.set_catallactic(j.at("catallactic").get<std::vector<Catallactic>>());
+        x.set_cemental(j.at("cemental").get<std::vector<Cemental>>());
+        x.set_chytridiaceae(j.at("Chytridiaceae").get<std::vector<ChytridiaceaeElement>>());
+        x.set_discordia(j.at("Discordia").get<std::vector<DiscordiaElement>>());
+        x.set_endomyces(j.at("Endomyces").get<std::vector<Endomyce>>());
+        x.set_epinephelidae(j.at("Epinephelidae").get<std::vector<Epinephelidae>>());
+        x.set_eupatorium(j.at("Eupatorium").get<std::vector<Eupatorium>>());
+        x.set_gryphosaurus(j.at("Gryphosaurus").get<std::vector<GryphosaurusElement>>());
+        x.set_koryak(j.at("Koryak").get<std::vector<Koryak>>());
+        x.set_lavinia(j.at("Lavinia").get<std::vector<LaviniaElement>>());
+        x.set_oskar(j.at("Oskar").get<std::vector<OskarElement>>());
+        x.set_rebecca(j.at("Rebecca").get<std::vector<RebeccaElement>>());
+        x.set_rhomboganoidei(j.at("Rhomboganoidei").get<std::vector<Rhomboganoidei>>());
+        x.set_rigsmal(j.at("Rigsmal").get<bool>());
+        x.set_ruellia(j.at("Ruellia").get<std::vector<Ruellia>>());
+        x.set_school(j.at("School").get<std::vector<School>>());
+        x.set_shakespearolater(j.at("Shakespearolater").get<std::vector<Shakespearolater>>());
+        x.set_svan(j.at("Svan").get<std::vector<double>>());
+        x.set_wayao(j.at("Wayao").get<std::map<std::string, double>>());
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["Abranchiata"] = x.get_abranchiata();
+        j["academe"] = x.get_academe();
+        j["acquirable"] = x.get_acquirable();
+        j["aerometry"] = x.get_aerometry();
+        j["alexin"] = x.get_alexin();
+        j["alleviate"] = x.get_alleviate();
+        j["amaas"] = x.get_amaas();
+        j["ambassage"] = x.get_ambassage();
+        j["amphithyron"] = x.get_amphithyron();
+        j["Andriana"] = x.get_andriana();
+        j["ankee"] = x.get_ankee();
+        j["annihilator"] = x.get_annihilator();
+        j["annulose"] = x.get_annulose();
+        j["Ansarie"] = x.get_ansarie();
+        j["aphasia"] = x.get_aphasia();
+        j["asprawl"] = x.get_asprawl();
+        j["attractive"] = x.get_attractive();
+        j["barksome"] = x.get_barksome();
+        j["bedesman"] = x.get_bedesman();
+        j["belard"] = x.get_belard();
+        j["bocking"] = x.get_bocking();
+        j["brawlingly"] = x.get_brawlingly();
+        j["brookie"] = x.get_brookie();
+        j["bumboatman"] = x.get_bumboatman();
+        j["bystreet"] = x.get_bystreet();
+        j["calaverite"] = x.get_calaverite();
+        j["catallactic"] = x.get_catallactic();
+        j["cemental"] = x.get_cemental();
+        j["Chytridiaceae"] = x.get_chytridiaceae();
+        j["Discordia"] = x.get_discordia();
+        j["Endomyces"] = x.get_endomyces();
+        j["Epinephelidae"] = x.get_epinephelidae();
+        j["Eupatorium"] = x.get_eupatorium();
+        j["Gryphosaurus"] = x.get_gryphosaurus();
+        j["Koryak"] = x.get_koryak();
+        j["Lavinia"] = x.get_lavinia();
+        j["Oskar"] = x.get_oskar();
+        j["Rebecca"] = x.get_rebecca();
+        j["Rhomboganoidei"] = x.get_rhomboganoidei();
+        j["Rigsmal"] = x.get_rigsmal();
+        j["Ruellia"] = x.get_ruellia();
+        j["School"] = x.get_school();
+        j["Shakespearolater"] = x.get_shakespearolater();
+        j["Svan"] = x.get_svan();
+        j["Wayao"] = x.get_wayao();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(const json & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, const std::variant<bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::AlleviateClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::AlleviateClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AlleviateClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>>::from_json(const json & j, std::variant<bool, quicktype::Rebecca, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, int64_t>>::to_json(json & j, const std::variant<bool, quicktype::Rebecca, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::string>>::from_json(const json & j, std::variant<std::vector<json>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::string>>::to_json(json & j, const std::variant<std::vector<json>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::AnkeeClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnkeeClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AnkeeClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::AnsarieClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::AnsarieClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::AnsarieClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::AnsarieClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(const json & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, const std::variant<double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::string>>::from_json(const json & j, std::variant<bool, double, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::string>>::to_json(json & j, const std::variant<bool, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>>::from_json(const json & j, std::variant<bool, quicktype::ChytridiaceaeClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::ChytridiaceaeClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::ChytridiaceaeClass>>::to_json(json & j, const std::variant<bool, quicktype::ChytridiaceaeClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::ChytridiaceaeClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::DiscordiaClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::DiscordiaClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::DiscordiaClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::DiscordiaClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::from_json(const json & j, std::variant<int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::string>>::to_json(json & j, const std::variant<int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::string>>::from_json(const json & j, std::variant<bool, int64_t, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::string>>::to_json(json & j, const std::variant<bool, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::GryphosaurusClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::GryphosaurusClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::GryphosaurusClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>>::from_json(const json & j, std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, std::optional<int64_t>>, std::string>>::to_json(json & j, const std::variant<std::map<std::string, std::optional<int64_t>>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LaviniaClass, std::string>>::from_json(const json & j, std::variant<quicktype::LaviniaClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::LaviniaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LaviniaClass, std::string>>::to_json(json & j, const std::variant<quicktype::LaviniaClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LaviniaClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::OskarClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::OskarClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::OskarClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::OskarClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::OskarClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>>::from_json(const json & j, std::variant<quicktype::Rebecca, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rebecca, int64_t, std::string>>::to_json(json & j, const std::variant<quicktype::Rebecca, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::Rebecca, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>>::from_json(const json & j, std::variant<bool, quicktype::Rebecca, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rebecca>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::Rebecca, std::string>>::to_json(json & j, const std::variant<bool, quicktype::Rebecca, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::Rebecca>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations3.json/code-format-with-struct--67c848c66185/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations3.json/code-format-with-struct--67c848c66185/quicktype.hpp
new file mode 100644
index 0000000..4dbc681
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations3.json/code-format-with-struct--67c848c66185/quicktype.hpp
@@ -0,0 +1,2270 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    struct JurorClass {
+        nlohmann::json adipsy;
+        nlohmann::json auxiliator;
+        nlohmann::json benda;
+        nlohmann::json benjamin;
+        nlohmann::json brandling;
+        nlohmann::json epicurishly;
+        nlohmann::json eremochaetous;
+        nlohmann::json marten;
+        nlohmann::json monocline;
+        nlohmann::json olea;
+        nlohmann::json palgat;
+        nlohmann::json pennyworth;
+        nlohmann::json pioury;
+        nlohmann::json pragmatistic;
+        nlohmann::json stylelessness;
+        nlohmann::json systematical;
+        nlohmann::json thready;
+        nlohmann::json uncontemporary;
+        nlohmann::json uncouched;
+        nlohmann::json uninhabitedness;
+    };
+
+    using JurorElement = std::variant<bool, JurorClass>;
+
+    using Kongoni = std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>;
+
+    struct LadronismClass {
+        nlohmann::json acclaimer;
+        nlohmann::json achree;
+        nlohmann::json base;
+        nlohmann::json conundrumize;
+        nlohmann::json degerminator;
+        nlohmann::json describable;
+        nlohmann::json exasperatedly;
+        nlohmann::json heroine;
+        nlohmann::json indazin;
+        nlohmann::json luteous;
+        nlohmann::json papular;
+        nlohmann::json pritch;
+        nlohmann::json prodenia;
+        nlohmann::json seege;
+        nlohmann::json shopgirl;
+        nlohmann::json tragedietta;
+        nlohmann::json unsparse;
+        nlohmann::json uplook;
+        nlohmann::json vermiformis;
+        nlohmann::json whafabout;
+    };
+
+    using LadronismElement = std::variant<LadronismClass, double, std::string>;
+
+    struct LandlubberlyClass {
+        nlohmann::json acropoleis;
+        nlohmann::json aminate;
+        nlohmann::json amyraldism;
+        nlohmann::json bipenniform;
+        nlohmann::json bugre;
+        nlohmann::json calycule;
+        nlohmann::json caoutchouc;
+        nlohmann::json disprover;
+        nlohmann::json fitroot;
+        nlohmann::json fulgently;
+        nlohmann::json kickup;
+        nlohmann::json laevoversion;
+        nlohmann::json moter;
+        nlohmann::json objectivity;
+        nlohmann::json posterity;
+        nlohmann::json postnuptial;
+        nlohmann::json precedentary;
+        nlohmann::json saddling;
+        nlohmann::json subcurrent;
+        nlohmann::json unrecriminative;
+    };
+
+    using LandlubberlyElement = std::variant<bool, LandlubberlyClass, int64_t>;
+
+    using Listener = std::variant<std::vector<nlohmann::json>, int64_t>;
+
+    struct LupusClass {
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chlorioninae;
+        std::optional<int64_t> corvinae;
+        std::optional<int64_t> crassina;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> exiguity;
+        std::optional<int64_t> farcist;
+        std::optional<int64_t> holographical;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> ichthyophagan;
+        std::optional<int64_t> implacable;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> outshiner;
+        std::optional<int64_t> overweather;
+        std::optional<int64_t> protonegroid;
+        std::optional<int64_t> shallowish;
+        std::optional<int64_t> snoke;
+        std::optional<int64_t> snout;
+        std::optional<int64_t> surveillance;
+        std::optional<int64_t> threshingtime;
+        std::optional<int64_t> thysanocarpus;
+        std::optional<int64_t> unsignificantly;
+        std::optional<int64_t> unsnap;
+        std::optional<int64_t> vendible;
+    };
+
+    using LupusElement = std::variant<LupusClass, int64_t>;
+
+    struct Maslin {
+        std::optional<int64_t> alicant;
+        nlohmann::json antiatonement;
+        std::optional<int64_t> anticorrosive;
+        nlohmann::json aphidozer;
+        nlohmann::json bakuninist;
+        std::optional<int64_t> be;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chub;
+        std::optional<int64_t> cuprosilicon;
+        std::optional<int64_t> curtailedly;
+        std::optional<int64_t> dellenite;
+        std::optional<int64_t> dimitry;
+        std::optional<std::string> disdiapason;
+        nlohmann::json edifying;
+        std::optional<int64_t> ethmoiditis;
+        nlohmann::json gastralgy;
+        std::optional<int64_t> goatherd;
+        std::optional<int64_t> hammerdress;
+        nlohmann::json hangfire;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> lacunosity;
+        nlohmann::json longiloquence;
+        std::optional<int64_t> mameliere;
+        nlohmann::json motherless;
+        nlohmann::json nonbookish;
+        nlohmann::json noncorrodible;
+        nlohmann::json nonsensicality;
+        std::optional<int64_t> oafishly;
+        nlohmann::json pfund;
+        nlohmann::json preadvisory;
+        nlohmann::json retroflexed;
+        std::optional<int64_t> saccharulmic;
+        std::optional<int64_t> scowlful;
+        nlohmann::json secluded;
+        nlohmann::json slackage;
+        std::optional<int64_t> sphaeridial;
+        nlohmann::json spondulics;
+        std::optional<int64_t> subsecive;
+        nlohmann::json swellmobsman;
+        std::optional<int64_t> trachyglossate;
+        nlohmann::json trialogue;
+        std::optional<int64_t> unassuaged;
+        nlohmann::json ungross;
+        nlohmann::json unjudiciously;
+    };
+
+    struct MonaziteClass {
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+    };
+
+    using MonaziteElement = std::variant<MonaziteClass, double>;
+
+    using Monoliteral = std::variant<std::vector<nlohmann::json>, bool>;
+
+    struct MonotheisticallyClass {
+        nlohmann::json blaspheme;
+        std::optional<double> catharticalness;
+        nlohmann::json celiosalpingectomy;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json consummativeness;
+        std::optional<std::string> disdiapason;
+        nlohmann::json egestive;
+        nlohmann::json enchylema;
+        nlohmann::json gasconade;
+        nlohmann::json holidayer;
+        std::optional<bool> homocerc;
+        nlohmann::json intuitionalism;
+        nlohmann::json lophiostomate;
+        nlohmann::json nonbookish;
+        nlohmann::json nonvolition;
+        nlohmann::json palatableness;
+        nlohmann::json pimpery;
+        nlohmann::json previolation;
+        nlohmann::json reconveyance;
+        nlohmann::json registership;
+        nlohmann::json rhyacolite;
+        nlohmann::json smithereens;
+        nlohmann::json superedification;
+        nlohmann::json trust;
+        nlohmann::json whitestone;
+    };
+
+    using MonotheisticallyElement = std::variant<std::vector<nlohmann::json>, MonotheisticallyClass>;
+
+    using Montage = std::variant<std::vector<nlohmann::json>, double, std::string>;
+
+    using Moralness = std::optional<std::variant<std::vector<nlohmann::json>, double>>;
+
+    using Mulishly = std::optional<std::variant<std::vector<int64_t>, double>>;
+
+    using Myoscope = std::variant<std::vector<nlohmann::json>, bool, int64_t>;
+
+    using Neuromastic = std::variant<std::vector<nlohmann::json>, double>;
+
+    struct Noncontributing {
+        std::string estevin;
+        double jolterhead;
+        int64_t sauternes;
+        bool sparsely;
+        nlohmann::json unrequested;
+    };
+
+    using Nonnervous = std::variant<bool, int64_t>;
+
+    using Nonvaluation = std::variant<std::vector<nlohmann::json>, bool, double>;
+
+    struct OccupationalistClass {
+        nlohmann::json beholdable;
+        nlohmann::json brotuliform;
+        nlohmann::json chimakum;
+        nlohmann::json doodler;
+        nlohmann::json emulsin;
+        nlohmann::json fin;
+        nlohmann::json flourishing;
+        nlohmann::json flueless;
+        nlohmann::json furtively;
+        nlohmann::json gritter;
+        nlohmann::json interwish;
+        nlohmann::json monoxylic;
+        nlohmann::json myristic;
+        nlohmann::json nightwear;
+        nlohmann::json peruser;
+        nlohmann::json theoastrological;
+        nlohmann::json thumby;
+        nlohmann::json tingitid;
+        nlohmann::json trailless;
+        nlohmann::json unpocketed;
+    };
+
+    using OccupationalistElement = std::optional<std::variant<std::vector<nlohmann::json>, OccupationalistClass>>;
+
+    struct OutrivalClass {
+        nlohmann::json adroitly;
+        nlohmann::json bridehood;
+        nlohmann::json castoroides;
+        nlohmann::json czechoslovak;
+        nlohmann::json diagenesis;
+        nlohmann::json dihexahedron;
+        nlohmann::json dopester;
+        nlohmann::json eumerism;
+        nlohmann::json flyness;
+        nlohmann::json fouler;
+        nlohmann::json laudanosine;
+        nlohmann::json lingulidae;
+        nlohmann::json minutary;
+        nlohmann::json mitra;
+        nlohmann::json opisthorchiasis;
+        nlohmann::json pensively;
+        nlohmann::json pubigerous;
+        nlohmann::json rebellious;
+        nlohmann::json recodify;
+        nlohmann::json unpaced;
+    };
+
+    using OutrivalElement = std::optional<std::variant<OutrivalClass, double>>;
+
+    using Paleographically = std::variant<double, std::map<std::string, std::optional<int64_t>>>;
+
+    using Pamphletwise = std::variant<int64_t, std::map<std::string, int64_t>, std::string>;
+
+    using Pediatric = std::optional<std::variant<bool, double>>;
+
+    struct PiaculumClass {
+        std::optional<int64_t> alada;
+        std::optional<int64_t> amphistomous;
+        std::optional<int64_t> boysenberry;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> decardinalize;
+        std::optional<int64_t> discouragement;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> doitrified;
+        std::optional<int64_t> hexaspermous;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> insinking;
+        std::optional<int64_t> loathfulness;
+        std::optional<int64_t> miasmatical;
+        std::optional<int64_t> neurofibril;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> phonendoscope;
+        std::optional<int64_t> pilferment;
+        std::optional<int64_t> predismissory;
+        std::optional<int64_t> preinscription;
+        std::optional<int64_t> quotative;
+        std::optional<int64_t> sienna;
+        std::optional<int64_t> thorax;
+        std::optional<int64_t> yachting;
+        std::optional<int64_t> zipper;
+    };
+
+    using PiaculumElement = std::variant<PiaculumClass, double>;
+
+    using Piccadilly = std::optional<std::variant<double, std::string>>;
+
+    using Piffler = std::variant<std::vector<nlohmann::json>, MonaziteClass>;
+
+    using Pithful = std::optional<std::variant<bool, int64_t>>;
+
+    using Placuntiti = std::variant<int64_t, std::map<std::string, int64_t>>;
+
+    using Plectopterous = std::variant<double, std::map<std::string, int64_t>>;
+
+    struct Pneumocele {
+        nlohmann::json carbonarism;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json cineolic;
+        nlohmann::json cobbly;
+        nlohmann::json conchyliferous;
+        nlohmann::json congregation;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enterotomy;
+        nlohmann::json entophytal;
+        nlohmann::json fewtrils;
+        nlohmann::json herem;
+        std::optional<bool> homocerc;
+        nlohmann::json koniga;
+        nlohmann::json meticulosity;
+        nlohmann::json micky;
+        nlohmann::json mismarriage;
+        nlohmann::json neurotrophic;
+        nlohmann::json nonbookish;
+        nlohmann::json persuasively;
+        nlohmann::json replaceable;
+        nlohmann::json silex;
+        nlohmann::json taillight;
+        nlohmann::json unjealous;
+        nlohmann::json visitorial;
+    };
+
+    using Poliorcetic = std::variant<bool, MonaziteClass>;
+
+    using Poormaster = std::optional<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>;
+
+    struct PotwhiskyClass {
+        nlohmann::json arciform;
+        nlohmann::json cresolin;
+        nlohmann::json disheartener;
+        nlohmann::json disproportionable;
+        nlohmann::json euchorda;
+        nlohmann::json ferryway;
+        nlohmann::json filamentiferous;
+        nlohmann::json flemish;
+        nlohmann::json forgainst;
+        nlohmann::json grainering;
+        nlohmann::json irrevoluble;
+        nlohmann::json kindredship;
+        nlohmann::json pinguitudinous;
+        nlohmann::json simpletonic;
+        nlohmann::json singsong;
+        nlohmann::json submergement;
+        nlohmann::json supraoesophagal;
+        nlohmann::json thrashel;
+        nlohmann::json tyremesis;
+        nlohmann::json yoruba;
+    };
+
+    using PotwhiskyElement = std::optional<std::variant<PotwhiskyClass, int64_t>>;
+
+    using Practicalizer = std::variant<std::vector<nlohmann::json>, MonaziteClass, std::string>;
+
+    struct PrefreshmanClass {
+        nlohmann::json azorubine;
+        nlohmann::json choroiditis;
+        nlohmann::json coagulatory;
+        nlohmann::json cyclorama;
+        nlohmann::json dolphus;
+        nlohmann::json duckhearted;
+        nlohmann::json ficus;
+        nlohmann::json gemaric;
+        nlohmann::json jugation;
+        nlohmann::json myoliposis;
+        nlohmann::json nonnomination;
+        nlohmann::json palay;
+        nlohmann::json pentactinal;
+        nlohmann::json phaet;
+        nlohmann::json piquant;
+        nlohmann::json registration;
+        nlohmann::json remancipation;
+        nlohmann::json scutatiform;
+        nlohmann::json theodolite;
+        nlohmann::json underward;
+    };
+
+    using PrefreshmanElement = std::variant<std::vector<nlohmann::json>, PrefreshmanClass, std::string>;
+
+    using Prehensility = std::variant<std::vector<nlohmann::json>, bool, MonaziteClass>;
+
+    using Prevoidance = std::variant<std::vector<int64_t>, MonaziteClass, int64_t>;
+
+    using Protext = std::variant<std::vector<int64_t>, bool, MonaziteClass>;
+
+    struct TopLevel {
+        std::vector<JurorElement> juror;
+        std::vector<Kongoni> kongoni;
+        std::vector<LadronismElement> ladronism;
+        std::vector<LandlubberlyElement> landlubberly;
+        std::vector<Listener> listener;
+        std::vector<LupusElement> lupus;
+        std::vector<Maslin> maslin;
+        std::vector<MonaziteElement> monazite;
+        std::vector<Monoliteral> monoliteral;
+        std::vector<MonotheisticallyElement> monotheistically;
+        std::vector<Montage> montage;
+        std::vector<Moralness> moralness;
+        std::vector<std::optional<MonaziteClass>> mowra;
+        std::vector<Mulishly> mulishly;
+        std::vector<Myoscope> myoscope;
+        std::vector<std::optional<std::vector<std::optional<int64_t>>>> nach;
+        std::vector<Neuromastic> neuromastic;
+        std::vector<Noncontributing> noncontributing;
+        std::vector<Nonnervous> nonnervous;
+        std::vector<Nonvaluation> nonvaluation;
+        std::vector<OccupationalistElement> occupationalist;
+        std::vector<OutrivalElement> outrival;
+        std::vector<Paleographically> paleographically;
+        std::vector<Pamphletwise> pamphletwise;
+        std::vector<Pediatric> pediatrics;
+        std::vector<bool> perceptive;
+        std::vector<PiaculumElement> piaculum;
+        std::vector<Piccadilly> piccadilly;
+        std::vector<Piffler> piffler;
+        std::vector<Pithful> pithful;
+        std::vector<Placuntiti> placuntitis;
+        std::vector<Plectopterous> plectopterous;
+        std::vector<std::optional<Pneumocele>> pneumocele;
+        std::vector<Poliorcetic> poliorcetic;
+        std::vector<Poormaster> poormaster;
+        std::vector<PotwhiskyElement> potwhisky;
+        std::vector<Practicalizer> practicalizer;
+        std::vector<PrefreshmanElement> prefreshman;
+        std::vector<Prehensility> prehensility;
+        std::vector<Prevoidance> prevoidance;
+        std::vector<std::map<std::string, std::optional<int64_t>>> probant;
+        std::vector<Protext> protext;
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, JurorClass & x);
+void to_json(json & j, const JurorClass & x);
+
+void from_json(const json & j, LadronismClass & x);
+void to_json(json & j, const LadronismClass & x);
+
+void from_json(const json & j, LandlubberlyClass & x);
+void to_json(json & j, const LandlubberlyClass & x);
+
+void from_json(const json & j, LupusClass & x);
+void to_json(json & j, const LupusClass & x);
+
+void from_json(const json & j, Maslin & x);
+void to_json(json & j, const Maslin & x);
+
+void from_json(const json & j, MonaziteClass & x);
+void to_json(json & j, const MonaziteClass & x);
+
+void from_json(const json & j, MonotheisticallyClass & x);
+void to_json(json & j, const MonotheisticallyClass & x);
+
+void from_json(const json & j, Noncontributing & x);
+void to_json(json & j, const Noncontributing & x);
+
+void from_json(const json & j, OccupationalistClass & x);
+void to_json(json & j, const OccupationalistClass & x);
+
+void from_json(const json & j, OutrivalClass & x);
+void to_json(json & j, const OutrivalClass & x);
+
+void from_json(const json & j, PiaculumClass & x);
+void to_json(json & j, const PiaculumClass & x);
+
+void from_json(const json & j, Pneumocele & x);
+void to_json(json & j, const Pneumocele & x);
+
+void from_json(const json & j, PotwhiskyClass & x);
+void to_json(json & j, const PotwhiskyClass & x);
+
+void from_json(const json & j, PrefreshmanClass & x);
+void to_json(json & j, const PrefreshmanClass & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<bool, quicktype::JurorClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::JurorClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::JurorClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::LadronismClass, double, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::LadronismClass, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LupusClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::LupusClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::LupusClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::MonaziteClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::MonaziteClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::MonaziteClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t>> {
+    static void from_json(const json & j, std::variant<bool, int64_t> & x);
+    static void to_json(json & j, const std::variant<bool, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::OccupationalistClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::OutrivalClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::OutrivalClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::OutrivalClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(const json & j, std::variant<bool, double> & x);
+    static void to_json(json & j, const std::variant<bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PiaculumClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::PiaculumClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::PiaculumClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::MonaziteClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::PotwhiskyClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::PotwhiskyClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, JurorClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.adipsy = get_untyped(j, "adipsy");
+        x.auxiliator = get_untyped(j, "auxiliator");
+        x.benda = get_untyped(j, "benda");
+        x.benjamin = get_untyped(j, "benjamin");
+        x.brandling = get_untyped(j, "brandling");
+        x.epicurishly = get_untyped(j, "epicurishly");
+        x.eremochaetous = get_untyped(j, "eremochaetous");
+        x.marten = get_untyped(j, "marten");
+        x.monocline = get_untyped(j, "monocline");
+        x.olea = get_untyped(j, "Olea");
+        x.palgat = get_untyped(j, "palgat");
+        x.pennyworth = get_untyped(j, "pennyworth");
+        x.pioury = get_untyped(j, "pioury");
+        x.pragmatistic = get_untyped(j, "pragmatistic");
+        x.stylelessness = get_untyped(j, "stylelessness");
+        x.systematical = get_untyped(j, "systematical");
+        x.thready = get_untyped(j, "thready");
+        x.uncontemporary = get_untyped(j, "uncontemporary");
+        x.uncouched = get_untyped(j, "uncouched");
+        x.uninhabitedness = get_untyped(j, "uninhabitedness");
+    }
+
+    inline void to_json(json & j, const JurorClass & x) {
+        j = json::object();
+        j["adipsy"] = x.adipsy;
+        j["auxiliator"] = x.auxiliator;
+        j["benda"] = x.benda;
+        j["benjamin"] = x.benjamin;
+        j["brandling"] = x.brandling;
+        j["epicurishly"] = x.epicurishly;
+        j["eremochaetous"] = x.eremochaetous;
+        j["marten"] = x.marten;
+        j["monocline"] = x.monocline;
+        j["Olea"] = x.olea;
+        j["palgat"] = x.palgat;
+        j["pennyworth"] = x.pennyworth;
+        j["pioury"] = x.pioury;
+        j["pragmatistic"] = x.pragmatistic;
+        j["stylelessness"] = x.stylelessness;
+        j["systematical"] = x.systematical;
+        j["thready"] = x.thready;
+        j["uncontemporary"] = x.uncontemporary;
+        j["uncouched"] = x.uncouched;
+        j["uninhabitedness"] = x.uninhabitedness;
+    }
+
+    inline void from_json(const json & j, LadronismClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.acclaimer = get_untyped(j, "acclaimer");
+        x.achree = get_untyped(j, "achree");
+        x.base = get_untyped(j, "base");
+        x.conundrumize = get_untyped(j, "conundrumize");
+        x.degerminator = get_untyped(j, "degerminator");
+        x.describable = get_untyped(j, "describable");
+        x.exasperatedly = get_untyped(j, "exasperatedly");
+        x.heroine = get_untyped(j, "heroine");
+        x.indazin = get_untyped(j, "indazin");
+        x.luteous = get_untyped(j, "luteous");
+        x.papular = get_untyped(j, "papular");
+        x.pritch = get_untyped(j, "pritch");
+        x.prodenia = get_untyped(j, "Prodenia");
+        x.seege = get_untyped(j, "seege");
+        x.shopgirl = get_untyped(j, "shopgirl");
+        x.tragedietta = get_untyped(j, "tragedietta");
+        x.unsparse = get_untyped(j, "unsparse");
+        x.uplook = get_untyped(j, "uplook");
+        x.vermiformis = get_untyped(j, "vermiformis");
+        x.whafabout = get_untyped(j, "whafabout");
+    }
+
+    inline void to_json(json & j, const LadronismClass & x) {
+        j = json::object();
+        j["acclaimer"] = x.acclaimer;
+        j["achree"] = x.achree;
+        j["base"] = x.base;
+        j["conundrumize"] = x.conundrumize;
+        j["degerminator"] = x.degerminator;
+        j["describable"] = x.describable;
+        j["exasperatedly"] = x.exasperatedly;
+        j["heroine"] = x.heroine;
+        j["indazin"] = x.indazin;
+        j["luteous"] = x.luteous;
+        j["papular"] = x.papular;
+        j["pritch"] = x.pritch;
+        j["Prodenia"] = x.prodenia;
+        j["seege"] = x.seege;
+        j["shopgirl"] = x.shopgirl;
+        j["tragedietta"] = x.tragedietta;
+        j["unsparse"] = x.unsparse;
+        j["uplook"] = x.uplook;
+        j["vermiformis"] = x.vermiformis;
+        j["whafabout"] = x.whafabout;
+    }
+
+    inline void from_json(const json & j, LandlubberlyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.acropoleis = get_untyped(j, "acropoleis");
+        x.aminate = get_untyped(j, "aminate");
+        x.amyraldism = get_untyped(j, "Amyraldism");
+        x.bipenniform = get_untyped(j, "bipenniform");
+        x.bugre = get_untyped(j, "bugre");
+        x.calycule = get_untyped(j, "calycule");
+        x.caoutchouc = get_untyped(j, "caoutchouc");
+        x.disprover = get_untyped(j, "disprover");
+        x.fitroot = get_untyped(j, "fitroot");
+        x.fulgently = get_untyped(j, "fulgently");
+        x.kickup = get_untyped(j, "kickup");
+        x.laevoversion = get_untyped(j, "laevoversion");
+        x.moter = get_untyped(j, "moter");
+        x.objectivity = get_untyped(j, "objectivity");
+        x.posterity = get_untyped(j, "posterity");
+        x.postnuptial = get_untyped(j, "postnuptial");
+        x.precedentary = get_untyped(j, "precedentary");
+        x.saddling = get_untyped(j, "saddling");
+        x.subcurrent = get_untyped(j, "subcurrent");
+        x.unrecriminative = get_untyped(j, "unrecriminative");
+    }
+
+    inline void to_json(json & j, const LandlubberlyClass & x) {
+        j = json::object();
+        j["acropoleis"] = x.acropoleis;
+        j["aminate"] = x.aminate;
+        j["Amyraldism"] = x.amyraldism;
+        j["bipenniform"] = x.bipenniform;
+        j["bugre"] = x.bugre;
+        j["calycule"] = x.calycule;
+        j["caoutchouc"] = x.caoutchouc;
+        j["disprover"] = x.disprover;
+        j["fitroot"] = x.fitroot;
+        j["fulgently"] = x.fulgently;
+        j["kickup"] = x.kickup;
+        j["laevoversion"] = x.laevoversion;
+        j["moter"] = x.moter;
+        j["objectivity"] = x.objectivity;
+        j["posterity"] = x.posterity;
+        j["postnuptial"] = x.postnuptial;
+        j["precedentary"] = x.precedentary;
+        j["saddling"] = x.saddling;
+        j["subcurrent"] = x.subcurrent;
+        j["unrecriminative"] = x.unrecriminative;
+    }
+
+    inline void from_json(const json & j, LupusClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.chlorioninae = get_stack_optional<int64_t>(j, "Chlorioninae");
+        x.corvinae = get_stack_optional<int64_t>(j, "Corvinae");
+        x.crassina = get_stack_optional<int64_t>(j, "Crassina");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.exiguity = get_stack_optional<int64_t>(j, "exiguity");
+        x.farcist = get_stack_optional<int64_t>(j, "farcist");
+        x.holographical = get_stack_optional<int64_t>(j, "holographical");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.ichthyophagan = get_stack_optional<int64_t>(j, "ichthyophagan");
+        x.implacable = get_stack_optional<int64_t>(j, "implacable");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.outshiner = get_stack_optional<int64_t>(j, "outshiner");
+        x.overweather = get_stack_optional<int64_t>(j, "overweather");
+        x.protonegroid = get_stack_optional<int64_t>(j, "protonegroid");
+        x.shallowish = get_stack_optional<int64_t>(j, "shallowish");
+        x.snoke = get_stack_optional<int64_t>(j, "snoke");
+        x.snout = get_stack_optional<int64_t>(j, "snout");
+        x.surveillance = get_stack_optional<int64_t>(j, "surveillance");
+        x.threshingtime = get_stack_optional<int64_t>(j, "threshingtime");
+        x.thysanocarpus = get_stack_optional<int64_t>(j, "Thysanocarpus");
+        x.unsignificantly = get_stack_optional<int64_t>(j, "unsignificantly");
+        x.unsnap = get_stack_optional<int64_t>(j, "unsnap");
+        x.vendible = get_stack_optional<int64_t>(j, "vendible");
+    }
+
+    inline void to_json(json & j, const LupusClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["Chlorioninae"] = x.chlorioninae;
+        j["Corvinae"] = x.corvinae;
+        j["Crassina"] = x.crassina;
+        j["disdiapason"] = x.disdiapason;
+        j["exiguity"] = x.exiguity;
+        j["farcist"] = x.farcist;
+        j["holographical"] = x.holographical;
+        j["homocerc"] = x.homocerc;
+        j["ichthyophagan"] = x.ichthyophagan;
+        j["implacable"] = x.implacable;
+        j["nonbookish"] = x.nonbookish;
+        j["outshiner"] = x.outshiner;
+        j["overweather"] = x.overweather;
+        j["protonegroid"] = x.protonegroid;
+        j["shallowish"] = x.shallowish;
+        j["snoke"] = x.snoke;
+        j["snout"] = x.snout;
+        j["surveillance"] = x.surveillance;
+        j["threshingtime"] = x.threshingtime;
+        j["Thysanocarpus"] = x.thysanocarpus;
+        j["unsignificantly"] = x.unsignificantly;
+        j["unsnap"] = x.unsnap;
+        j["vendible"] = x.vendible;
+    }
+
+    inline void from_json(const json & j, Maslin& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.alicant = get_stack_optional<int64_t>(j, "Alicant");
+        x.antiatonement = get_untyped(j, "antiatonement");
+        x.anticorrosive = get_stack_optional<int64_t>(j, "anticorrosive");
+        x.aphidozer = get_untyped(j, "aphidozer");
+        x.bakuninist = get_untyped(j, "Bakuninist");
+        x.be = get_stack_optional<int64_t>(j, "be");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.chub = get_stack_optional<int64_t>(j, "chub");
+        x.cuprosilicon = get_stack_optional<int64_t>(j, "cuprosilicon");
+        x.curtailedly = get_stack_optional<int64_t>(j, "curtailedly");
+        x.dellenite = get_stack_optional<int64_t>(j, "dellenite");
+        x.dimitry = get_stack_optional<int64_t>(j, "Dimitry");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.edifying = get_untyped(j, "edifying");
+        x.ethmoiditis = get_stack_optional<int64_t>(j, "ethmoiditis");
+        x.gastralgy = get_untyped(j, "gastralgy");
+        x.goatherd = get_stack_optional<int64_t>(j, "goatherd");
+        x.hammerdress = get_stack_optional<int64_t>(j, "hammerdress");
+        x.hangfire = get_untyped(j, "hangfire");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.lacunosity = get_stack_optional<int64_t>(j, "lacunosity");
+        x.longiloquence = get_untyped(j, "longiloquence");
+        x.mameliere = get_stack_optional<int64_t>(j, "mameliere");
+        x.motherless = get_untyped(j, "motherless");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.noncorrodible = get_untyped(j, "noncorrodible");
+        x.nonsensicality = get_untyped(j, "nonsensicality");
+        x.oafishly = get_stack_optional<int64_t>(j, "oafishly");
+        x.pfund = get_untyped(j, "pfund");
+        x.preadvisory = get_untyped(j, "preadvisory");
+        x.retroflexed = get_untyped(j, "retroflexed");
+        x.saccharulmic = get_stack_optional<int64_t>(j, "saccharulmic");
+        x.scowlful = get_stack_optional<int64_t>(j, "scowlful");
+        x.secluded = get_untyped(j, "secluded");
+        x.slackage = get_untyped(j, "slackage");
+        x.sphaeridial = get_stack_optional<int64_t>(j, "sphaeridial");
+        x.spondulics = get_untyped(j, "spondulics");
+        x.subsecive = get_stack_optional<int64_t>(j, "subsecive");
+        x.swellmobsman = get_untyped(j, "swellmobsman");
+        x.trachyglossate = get_stack_optional<int64_t>(j, "trachyglossate");
+        x.trialogue = get_untyped(j, "trialogue");
+        x.unassuaged = get_stack_optional<int64_t>(j, "unassuaged");
+        x.ungross = get_untyped(j, "ungross");
+        x.unjudiciously = get_untyped(j, "unjudiciously");
+    }
+
+    inline void to_json(json & j, const Maslin & x) {
+        j = json::object();
+        j["Alicant"] = x.alicant;
+        j["antiatonement"] = x.antiatonement;
+        j["anticorrosive"] = x.anticorrosive;
+        j["aphidozer"] = x.aphidozer;
+        j["Bakuninist"] = x.bakuninist;
+        j["be"] = x.be;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["chub"] = x.chub;
+        j["cuprosilicon"] = x.cuprosilicon;
+        j["curtailedly"] = x.curtailedly;
+        j["dellenite"] = x.dellenite;
+        j["Dimitry"] = x.dimitry;
+        j["disdiapason"] = x.disdiapason;
+        j["edifying"] = x.edifying;
+        j["ethmoiditis"] = x.ethmoiditis;
+        j["gastralgy"] = x.gastralgy;
+        j["goatherd"] = x.goatherd;
+        j["hammerdress"] = x.hammerdress;
+        j["hangfire"] = x.hangfire;
+        j["homocerc"] = x.homocerc;
+        j["lacunosity"] = x.lacunosity;
+        j["longiloquence"] = x.longiloquence;
+        j["mameliere"] = x.mameliere;
+        j["motherless"] = x.motherless;
+        j["nonbookish"] = x.nonbookish;
+        j["noncorrodible"] = x.noncorrodible;
+        j["nonsensicality"] = x.nonsensicality;
+        j["oafishly"] = x.oafishly;
+        j["pfund"] = x.pfund;
+        j["preadvisory"] = x.preadvisory;
+        j["retroflexed"] = x.retroflexed;
+        j["saccharulmic"] = x.saccharulmic;
+        j["scowlful"] = x.scowlful;
+        j["secluded"] = x.secluded;
+        j["slackage"] = x.slackage;
+        j["sphaeridial"] = x.sphaeridial;
+        j["spondulics"] = x.spondulics;
+        j["subsecive"] = x.subsecive;
+        j["swellmobsman"] = x.swellmobsman;
+        j["trachyglossate"] = x.trachyglossate;
+        j["trialogue"] = x.trialogue;
+        j["unassuaged"] = x.unassuaged;
+        j["ungross"] = x.ungross;
+        j["unjudiciously"] = x.unjudiciously;
+    }
+
+    inline void from_json(const json & j, MonaziteClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.catharticalness = j.at("catharticalness").get<double>();
+        x.chirotherium = j.at("Chirotherium").get<int64_t>();
+        x.disdiapason = j.at("disdiapason").get<std::string>();
+        x.homocerc = j.at("homocerc").get<bool>();
+        x.nonbookish = get_untyped(j, "nonbookish");
+    }
+
+    inline void to_json(json & j, const MonaziteClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["homocerc"] = x.homocerc;
+        j["nonbookish"] = x.nonbookish;
+    }
+
+    inline void from_json(const json & j, MonotheisticallyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.blaspheme = get_untyped(j, "blaspheme");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.celiosalpingectomy = get_untyped(j, "celiosalpingectomy");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.consummativeness = get_untyped(j, "consummativeness");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.egestive = get_untyped(j, "egestive");
+        x.enchylema = get_untyped(j, "enchylema");
+        x.gasconade = get_untyped(j, "gasconade");
+        x.holidayer = get_untyped(j, "holidayer");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.intuitionalism = get_untyped(j, "intuitionalism");
+        x.lophiostomate = get_untyped(j, "lophiostomate");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.nonvolition = get_untyped(j, "nonvolition");
+        x.palatableness = get_untyped(j, "palatableness");
+        x.pimpery = get_untyped(j, "pimpery");
+        x.previolation = get_untyped(j, "previolation");
+        x.reconveyance = get_untyped(j, "reconveyance");
+        x.registership = get_untyped(j, "registership");
+        x.rhyacolite = get_untyped(j, "rhyacolite");
+        x.smithereens = get_untyped(j, "smithereens");
+        x.superedification = get_untyped(j, "superedification");
+        x.trust = get_untyped(j, "trust");
+        x.whitestone = get_untyped(j, "whitestone");
+    }
+
+    inline void to_json(json & j, const MonotheisticallyClass & x) {
+        j = json::object();
+        j["blaspheme"] = x.blaspheme;
+        j["catharticalness"] = x.catharticalness;
+        j["celiosalpingectomy"] = x.celiosalpingectomy;
+        j["Chirotherium"] = x.chirotherium;
+        j["consummativeness"] = x.consummativeness;
+        j["disdiapason"] = x.disdiapason;
+        j["egestive"] = x.egestive;
+        j["enchylema"] = x.enchylema;
+        j["gasconade"] = x.gasconade;
+        j["holidayer"] = x.holidayer;
+        j["homocerc"] = x.homocerc;
+        j["intuitionalism"] = x.intuitionalism;
+        j["lophiostomate"] = x.lophiostomate;
+        j["nonbookish"] = x.nonbookish;
+        j["nonvolition"] = x.nonvolition;
+        j["palatableness"] = x.palatableness;
+        j["pimpery"] = x.pimpery;
+        j["previolation"] = x.previolation;
+        j["reconveyance"] = x.reconveyance;
+        j["registership"] = x.registership;
+        j["rhyacolite"] = x.rhyacolite;
+        j["smithereens"] = x.smithereens;
+        j["superedification"] = x.superedification;
+        j["trust"] = x.trust;
+        j["whitestone"] = x.whitestone;
+    }
+
+    inline void from_json(const json & j, Noncontributing& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.estevin = j.at("estevin").get<std::string>();
+        x.jolterhead = j.at("jolterhead").get<double>();
+        x.sauternes = j.at("sauternes").get<int64_t>();
+        x.sparsely = j.at("sparsely").get<bool>();
+        x.unrequested = get_untyped(j, "unrequested");
+    }
+
+    inline void to_json(json & j, const Noncontributing & x) {
+        j = json::object();
+        j["estevin"] = x.estevin;
+        j["jolterhead"] = x.jolterhead;
+        j["sauternes"] = x.sauternes;
+        j["sparsely"] = x.sparsely;
+        j["unrequested"] = x.unrequested;
+    }
+
+    inline void from_json(const json & j, OccupationalistClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.beholdable = get_untyped(j, "beholdable");
+        x.brotuliform = get_untyped(j, "brotuliform");
+        x.chimakum = get_untyped(j, "Chimakum");
+        x.doodler = get_untyped(j, "doodler");
+        x.emulsin = get_untyped(j, "emulsin");
+        x.fin = get_untyped(j, "Fin");
+        x.flourishing = get_untyped(j, "flourishing");
+        x.flueless = get_untyped(j, "flueless");
+        x.furtively = get_untyped(j, "furtively");
+        x.gritter = get_untyped(j, "gritter");
+        x.interwish = get_untyped(j, "interwish");
+        x.monoxylic = get_untyped(j, "monoxylic");
+        x.myristic = get_untyped(j, "myristic");
+        x.nightwear = get_untyped(j, "nightwear");
+        x.peruser = get_untyped(j, "peruser");
+        x.theoastrological = get_untyped(j, "theoastrological");
+        x.thumby = get_untyped(j, "thumby");
+        x.tingitid = get_untyped(j, "tingitid");
+        x.trailless = get_untyped(j, "trailless");
+        x.unpocketed = get_untyped(j, "unpocketed");
+    }
+
+    inline void to_json(json & j, const OccupationalistClass & x) {
+        j = json::object();
+        j["beholdable"] = x.beholdable;
+        j["brotuliform"] = x.brotuliform;
+        j["Chimakum"] = x.chimakum;
+        j["doodler"] = x.doodler;
+        j["emulsin"] = x.emulsin;
+        j["Fin"] = x.fin;
+        j["flourishing"] = x.flourishing;
+        j["flueless"] = x.flueless;
+        j["furtively"] = x.furtively;
+        j["gritter"] = x.gritter;
+        j["interwish"] = x.interwish;
+        j["monoxylic"] = x.monoxylic;
+        j["myristic"] = x.myristic;
+        j["nightwear"] = x.nightwear;
+        j["peruser"] = x.peruser;
+        j["theoastrological"] = x.theoastrological;
+        j["thumby"] = x.thumby;
+        j["tingitid"] = x.tingitid;
+        j["trailless"] = x.trailless;
+        j["unpocketed"] = x.unpocketed;
+    }
+
+    inline void from_json(const json & j, OutrivalClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.adroitly = get_untyped(j, "adroitly");
+        x.bridehood = get_untyped(j, "bridehood");
+        x.castoroides = get_untyped(j, "Castoroides");
+        x.czechoslovak = get_untyped(j, "Czechoslovak");
+        x.diagenesis = get_untyped(j, "diagenesis");
+        x.dihexahedron = get_untyped(j, "dihexahedron");
+        x.dopester = get_untyped(j, "dopester");
+        x.eumerism = get_untyped(j, "eumerism");
+        x.flyness = get_untyped(j, "flyness");
+        x.fouler = get_untyped(j, "fouler");
+        x.laudanosine = get_untyped(j, "laudanosine");
+        x.lingulidae = get_untyped(j, "Lingulidae");
+        x.minutary = get_untyped(j, "minutary");
+        x.mitra = get_untyped(j, "mitra");
+        x.opisthorchiasis = get_untyped(j, "opisthorchiasis");
+        x.pensively = get_untyped(j, "pensively");
+        x.pubigerous = get_untyped(j, "pubigerous");
+        x.rebellious = get_untyped(j, "rebellious");
+        x.recodify = get_untyped(j, "recodify");
+        x.unpaced = get_untyped(j, "unpaced");
+    }
+
+    inline void to_json(json & j, const OutrivalClass & x) {
+        j = json::object();
+        j["adroitly"] = x.adroitly;
+        j["bridehood"] = x.bridehood;
+        j["Castoroides"] = x.castoroides;
+        j["Czechoslovak"] = x.czechoslovak;
+        j["diagenesis"] = x.diagenesis;
+        j["dihexahedron"] = x.dihexahedron;
+        j["dopester"] = x.dopester;
+        j["eumerism"] = x.eumerism;
+        j["flyness"] = x.flyness;
+        j["fouler"] = x.fouler;
+        j["laudanosine"] = x.laudanosine;
+        j["Lingulidae"] = x.lingulidae;
+        j["minutary"] = x.minutary;
+        j["mitra"] = x.mitra;
+        j["opisthorchiasis"] = x.opisthorchiasis;
+        j["pensively"] = x.pensively;
+        j["pubigerous"] = x.pubigerous;
+        j["rebellious"] = x.rebellious;
+        j["recodify"] = x.recodify;
+        j["unpaced"] = x.unpaced;
+    }
+
+    inline void from_json(const json & j, PiaculumClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.alada = get_stack_optional<int64_t>(j, "alada");
+        x.amphistomous = get_stack_optional<int64_t>(j, "amphistomous");
+        x.boysenberry = get_stack_optional<int64_t>(j, "boysenberry");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.decardinalize = get_stack_optional<int64_t>(j, "decardinalize");
+        x.discouragement = get_stack_optional<int64_t>(j, "discouragement");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.doitrified = get_stack_optional<int64_t>(j, "doitrified");
+        x.hexaspermous = get_stack_optional<int64_t>(j, "hexaspermous");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.insinking = get_stack_optional<int64_t>(j, "insinking");
+        x.loathfulness = get_stack_optional<int64_t>(j, "loathfulness");
+        x.miasmatical = get_stack_optional<int64_t>(j, "miasmatical");
+        x.neurofibril = get_stack_optional<int64_t>(j, "neurofibril");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.phonendoscope = get_stack_optional<int64_t>(j, "phonendoscope");
+        x.pilferment = get_stack_optional<int64_t>(j, "pilferment");
+        x.predismissory = get_stack_optional<int64_t>(j, "predismissory");
+        x.preinscription = get_stack_optional<int64_t>(j, "preinscription");
+        x.quotative = get_stack_optional<int64_t>(j, "quotative");
+        x.sienna = get_stack_optional<int64_t>(j, "sienna");
+        x.thorax = get_stack_optional<int64_t>(j, "thorax");
+        x.yachting = get_stack_optional<int64_t>(j, "yachting");
+        x.zipper = get_stack_optional<int64_t>(j, "Zipper");
+    }
+
+    inline void to_json(json & j, const PiaculumClass & x) {
+        j = json::object();
+        j["alada"] = x.alada;
+        j["amphistomous"] = x.amphistomous;
+        j["boysenberry"] = x.boysenberry;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["decardinalize"] = x.decardinalize;
+        j["discouragement"] = x.discouragement;
+        j["disdiapason"] = x.disdiapason;
+        j["doitrified"] = x.doitrified;
+        j["hexaspermous"] = x.hexaspermous;
+        j["homocerc"] = x.homocerc;
+        j["insinking"] = x.insinking;
+        j["loathfulness"] = x.loathfulness;
+        j["miasmatical"] = x.miasmatical;
+        j["neurofibril"] = x.neurofibril;
+        j["nonbookish"] = x.nonbookish;
+        j["phonendoscope"] = x.phonendoscope;
+        j["pilferment"] = x.pilferment;
+        j["predismissory"] = x.predismissory;
+        j["preinscription"] = x.preinscription;
+        j["quotative"] = x.quotative;
+        j["sienna"] = x.sienna;
+        j["thorax"] = x.thorax;
+        j["yachting"] = x.yachting;
+        j["Zipper"] = x.zipper;
+    }
+
+    inline void from_json(const json & j, Pneumocele& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.carbonarism = get_untyped(j, "Carbonarism");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.cineolic = get_untyped(j, "cineolic");
+        x.cobbly = get_untyped(j, "cobbly");
+        x.conchyliferous = get_untyped(j, "conchyliferous");
+        x.congregation = get_untyped(j, "congregation");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.enterotomy = get_untyped(j, "enterotomy");
+        x.entophytal = get_untyped(j, "entophytal");
+        x.fewtrils = get_untyped(j, "fewtrils");
+        x.herem = get_untyped(j, "herem");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.koniga = get_untyped(j, "Koniga");
+        x.meticulosity = get_untyped(j, "meticulosity");
+        x.micky = get_untyped(j, "Micky");
+        x.mismarriage = get_untyped(j, "mismarriage");
+        x.neurotrophic = get_untyped(j, "neurotrophic");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.persuasively = get_untyped(j, "persuasively");
+        x.replaceable = get_untyped(j, "replaceable");
+        x.silex = get_untyped(j, "silex");
+        x.taillight = get_untyped(j, "taillight");
+        x.unjealous = get_untyped(j, "unjealous");
+        x.visitorial = get_untyped(j, "visitorial");
+    }
+
+    inline void to_json(json & j, const Pneumocele & x) {
+        j = json::object();
+        j["Carbonarism"] = x.carbonarism;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["cineolic"] = x.cineolic;
+        j["cobbly"] = x.cobbly;
+        j["conchyliferous"] = x.conchyliferous;
+        j["congregation"] = x.congregation;
+        j["disdiapason"] = x.disdiapason;
+        j["enterotomy"] = x.enterotomy;
+        j["entophytal"] = x.entophytal;
+        j["fewtrils"] = x.fewtrils;
+        j["herem"] = x.herem;
+        j["homocerc"] = x.homocerc;
+        j["Koniga"] = x.koniga;
+        j["meticulosity"] = x.meticulosity;
+        j["Micky"] = x.micky;
+        j["mismarriage"] = x.mismarriage;
+        j["neurotrophic"] = x.neurotrophic;
+        j["nonbookish"] = x.nonbookish;
+        j["persuasively"] = x.persuasively;
+        j["replaceable"] = x.replaceable;
+        j["silex"] = x.silex;
+        j["taillight"] = x.taillight;
+        j["unjealous"] = x.unjealous;
+        j["visitorial"] = x.visitorial;
+    }
+
+    inline void from_json(const json & j, PotwhiskyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.arciform = get_untyped(j, "arciform");
+        x.cresolin = get_untyped(j, "cresolin");
+        x.disheartener = get_untyped(j, "disheartener");
+        x.disproportionable = get_untyped(j, "disproportionable");
+        x.euchorda = get_untyped(j, "Euchorda");
+        x.ferryway = get_untyped(j, "ferryway");
+        x.filamentiferous = get_untyped(j, "filamentiferous");
+        x.flemish = get_untyped(j, "flemish");
+        x.forgainst = get_untyped(j, "forgainst");
+        x.grainering = get_untyped(j, "grainering");
+        x.irrevoluble = get_untyped(j, "irrevoluble");
+        x.kindredship = get_untyped(j, "kindredship");
+        x.pinguitudinous = get_untyped(j, "pinguitudinous");
+        x.simpletonic = get_untyped(j, "simpletonic");
+        x.singsong = get_untyped(j, "singsong");
+        x.submergement = get_untyped(j, "submergement");
+        x.supraoesophagal = get_untyped(j, "supraoesophagal");
+        x.thrashel = get_untyped(j, "thrashel");
+        x.tyremesis = get_untyped(j, "tyremesis");
+        x.yoruba = get_untyped(j, "Yoruba");
+    }
+
+    inline void to_json(json & j, const PotwhiskyClass & x) {
+        j = json::object();
+        j["arciform"] = x.arciform;
+        j["cresolin"] = x.cresolin;
+        j["disheartener"] = x.disheartener;
+        j["disproportionable"] = x.disproportionable;
+        j["Euchorda"] = x.euchorda;
+        j["ferryway"] = x.ferryway;
+        j["filamentiferous"] = x.filamentiferous;
+        j["flemish"] = x.flemish;
+        j["forgainst"] = x.forgainst;
+        j["grainering"] = x.grainering;
+        j["irrevoluble"] = x.irrevoluble;
+        j["kindredship"] = x.kindredship;
+        j["pinguitudinous"] = x.pinguitudinous;
+        j["simpletonic"] = x.simpletonic;
+        j["singsong"] = x.singsong;
+        j["submergement"] = x.submergement;
+        j["supraoesophagal"] = x.supraoesophagal;
+        j["thrashel"] = x.thrashel;
+        j["tyremesis"] = x.tyremesis;
+        j["Yoruba"] = x.yoruba;
+    }
+
+    inline void from_json(const json & j, PrefreshmanClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.azorubine = get_untyped(j, "azorubine");
+        x.choroiditis = get_untyped(j, "choroiditis");
+        x.coagulatory = get_untyped(j, "coagulatory");
+        x.cyclorama = get_untyped(j, "cyclorama");
+        x.dolphus = get_untyped(j, "Dolphus");
+        x.duckhearted = get_untyped(j, "duckhearted");
+        x.ficus = get_untyped(j, "Ficus");
+        x.gemaric = get_untyped(j, "Gemaric");
+        x.jugation = get_untyped(j, "jugation");
+        x.myoliposis = get_untyped(j, "myoliposis");
+        x.nonnomination = get_untyped(j, "nonnomination");
+        x.palay = get_untyped(j, "palay");
+        x.pentactinal = get_untyped(j, "pentactinal");
+        x.phaet = get_untyped(j, "Phaet");
+        x.piquant = get_untyped(j, "piquant");
+        x.registration = get_untyped(j, "registration");
+        x.remancipation = get_untyped(j, "remancipation");
+        x.scutatiform = get_untyped(j, "scutatiform");
+        x.theodolite = get_untyped(j, "theodolite");
+        x.underward = get_untyped(j, "underward");
+    }
+
+    inline void to_json(json & j, const PrefreshmanClass & x) {
+        j = json::object();
+        j["azorubine"] = x.azorubine;
+        j["choroiditis"] = x.choroiditis;
+        j["coagulatory"] = x.coagulatory;
+        j["cyclorama"] = x.cyclorama;
+        j["Dolphus"] = x.dolphus;
+        j["duckhearted"] = x.duckhearted;
+        j["Ficus"] = x.ficus;
+        j["Gemaric"] = x.gemaric;
+        j["jugation"] = x.jugation;
+        j["myoliposis"] = x.myoliposis;
+        j["nonnomination"] = x.nonnomination;
+        j["palay"] = x.palay;
+        j["pentactinal"] = x.pentactinal;
+        j["Phaet"] = x.phaet;
+        j["piquant"] = x.piquant;
+        j["registration"] = x.registration;
+        j["remancipation"] = x.remancipation;
+        j["scutatiform"] = x.scutatiform;
+        j["theodolite"] = x.theodolite;
+        j["underward"] = x.underward;
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.juror = j.at("juror").get<std::vector<JurorElement>>();
+        x.kongoni = j.at("kongoni").get<std::vector<Kongoni>>();
+        x.ladronism = j.at("ladronism").get<std::vector<LadronismElement>>();
+        x.landlubberly = j.at("landlubberly").get<std::vector<LandlubberlyElement>>();
+        x.listener = j.at("listener").get<std::vector<Listener>>();
+        x.lupus = j.at("lupus").get<std::vector<LupusElement>>();
+        x.maslin = j.at("maslin").get<std::vector<Maslin>>();
+        x.monazite = j.at("monazite").get<std::vector<MonaziteElement>>();
+        x.monoliteral = j.at("monoliteral").get<std::vector<Monoliteral>>();
+        x.monotheistically = j.at("monotheistically").get<std::vector<MonotheisticallyElement>>();
+        x.montage = j.at("montage").get<std::vector<Montage>>();
+        x.moralness = j.at("moralness").get<std::vector<Moralness>>();
+        x.mowra = j.at("mowra").get<std::vector<std::optional<MonaziteClass>>>();
+        x.mulishly = j.at("mulishly").get<std::vector<Mulishly>>();
+        x.myoscope = j.at("myoscope").get<std::vector<Myoscope>>();
+        x.nach = j.at("nach").get<std::vector<std::optional<std::vector<std::optional<int64_t>>>>>();
+        x.neuromastic = j.at("neuromastic").get<std::vector<Neuromastic>>();
+        x.noncontributing = j.at("noncontributing").get<std::vector<Noncontributing>>();
+        x.nonnervous = j.at("nonnervous").get<std::vector<Nonnervous>>();
+        x.nonvaluation = j.at("nonvaluation").get<std::vector<Nonvaluation>>();
+        x.occupationalist = j.at("occupationalist").get<std::vector<OccupationalistElement>>();
+        x.outrival = j.at("outrival").get<std::vector<OutrivalElement>>();
+        x.paleographically = j.at("paleographically").get<std::vector<Paleographically>>();
+        x.pamphletwise = j.at("pamphletwise").get<std::vector<Pamphletwise>>();
+        x.pediatrics = j.at("pediatrics").get<std::vector<Pediatric>>();
+        x.perceptive = j.at("perceptive").get<std::vector<bool>>();
+        x.piaculum = j.at("piaculum").get<std::vector<PiaculumElement>>();
+        x.piccadilly = j.at("piccadilly").get<std::vector<Piccadilly>>();
+        x.piffler = j.at("piffler").get<std::vector<Piffler>>();
+        x.pithful = j.at("pithful").get<std::vector<Pithful>>();
+        x.placuntitis = j.at("placuntitis").get<std::vector<Placuntiti>>();
+        x.plectopterous = j.at("plectopterous").get<std::vector<Plectopterous>>();
+        x.pneumocele = j.at("pneumocele").get<std::vector<std::optional<Pneumocele>>>();
+        x.poliorcetic = j.at("poliorcetic").get<std::vector<Poliorcetic>>();
+        x.poormaster = j.at("poormaster").get<std::vector<Poormaster>>();
+        x.potwhisky = j.at("potwhisky").get<std::vector<PotwhiskyElement>>();
+        x.practicalizer = j.at("practicalizer").get<std::vector<Practicalizer>>();
+        x.prefreshman = j.at("prefreshman").get<std::vector<PrefreshmanElement>>();
+        x.prehensility = j.at("prehensility").get<std::vector<Prehensility>>();
+        x.prevoidance = j.at("prevoidance").get<std::vector<Prevoidance>>();
+        x.probant = j.at("probant").get<std::vector<std::map<std::string, std::optional<int64_t>>>>();
+        x.protext = j.at("protext").get<std::vector<Protext>>();
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["juror"] = x.juror;
+        j["kongoni"] = x.kongoni;
+        j["ladronism"] = x.ladronism;
+        j["landlubberly"] = x.landlubberly;
+        j["listener"] = x.listener;
+        j["lupus"] = x.lupus;
+        j["maslin"] = x.maslin;
+        j["monazite"] = x.monazite;
+        j["monoliteral"] = x.monoliteral;
+        j["monotheistically"] = x.monotheistically;
+        j["montage"] = x.montage;
+        j["moralness"] = x.moralness;
+        j["mowra"] = x.mowra;
+        j["mulishly"] = x.mulishly;
+        j["myoscope"] = x.myoscope;
+        j["nach"] = x.nach;
+        j["neuromastic"] = x.neuromastic;
+        j["noncontributing"] = x.noncontributing;
+        j["nonnervous"] = x.nonnervous;
+        j["nonvaluation"] = x.nonvaluation;
+        j["occupationalist"] = x.occupationalist;
+        j["outrival"] = x.outrival;
+        j["paleographically"] = x.paleographically;
+        j["pamphletwise"] = x.pamphletwise;
+        j["pediatrics"] = x.pediatrics;
+        j["perceptive"] = x.perceptive;
+        j["piaculum"] = x.piaculum;
+        j["piccadilly"] = x.piccadilly;
+        j["piffler"] = x.piffler;
+        j["pithful"] = x.pithful;
+        j["placuntitis"] = x.placuntitis;
+        j["plectopterous"] = x.plectopterous;
+        j["pneumocele"] = x.pneumocele;
+        j["poliorcetic"] = x.poliorcetic;
+        j["poormaster"] = x.poormaster;
+        j["potwhisky"] = x.potwhisky;
+        j["practicalizer"] = x.practicalizer;
+        j["prefreshman"] = x.prefreshman;
+        j["prehensility"] = x.prehensility;
+        j["prevoidance"] = x.prevoidance;
+        j["probant"] = x.probant;
+        j["protext"] = x.protext;
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<bool, quicktype::JurorClass>>::from_json(const json & j, std::variant<bool, quicktype::JurorClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::JurorClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::JurorClass>>::to_json(json & j, const std::variant<bool, quicktype::JurorClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::JurorClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>>::from_json(const json & j, std::variant<quicktype::LadronismClass, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::LadronismClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>>::to_json(json & j, const std::variant<quicktype::LadronismClass, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LadronismClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>>::from_json(const json & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::LandlubberlyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>>::to_json(json & j, const std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::LandlubberlyClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LupusClass, int64_t>>::from_json(const json & j, std::variant<quicktype::LupusClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::LupusClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LupusClass, int64_t>>::to_json(json & j, const std::variant<quicktype::LupusClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LupusClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MonaziteClass, double>>::from_json(const json & j, std::variant<quicktype::MonaziteClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MonaziteClass, double>>::to_json(json & j, const std::variant<quicktype::MonaziteClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::from_json(const json & j, std::variant<std::vector<json>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::to_json(json & j, const std::variant<std::vector<json>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::MonotheisticallyClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonotheisticallyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::string>>::from_json(const json & j, std::variant<std::vector<json>, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::string>>::to_json(json & j, const std::variant<std::vector<json>, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::from_json(const json & j, std::variant<std::vector<json>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::to_json(json & j, const std::variant<std::vector<json>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, bool, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t>>::from_json(const json & j, std::variant<bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t>>::to_json(json & j, const std::variant<bool, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, double>>::from_json(const json & j, std::variant<std::vector<json>, bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, double>>::to_json(json & j, const std::variant<std::vector<json>, bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::OccupationalistClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::OccupationalistClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::OccupationalistClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OutrivalClass, double>>::from_json(const json & j, std::variant<quicktype::OutrivalClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::OutrivalClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OutrivalClass, double>>::to_json(json & j, const std::variant<quicktype::OutrivalClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::OutrivalClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<double, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(const json & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, const std::variant<bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PiaculumClass, double>>::from_json(const json & j, std::variant<quicktype::PiaculumClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::PiaculumClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PiaculumClass, double>>::to_json(json & j, const std::variant<quicktype::PiaculumClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PiaculumClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(const json & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, const std::variant<double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<bool, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>>::from_json(const json & j, std::variant<quicktype::PotwhiskyClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::PotwhiskyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>>::to_json(json & j, const std::variant<quicktype::PotwhiskyClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PotwhiskyClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::PrefreshmanClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::PrefreshmanClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations3.json/const-style-east-const--0048a2a7a881/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations3.json/const-style-east-const--0048a2a7a881/quicktype.hpp
new file mode 100644
index 0000000..6b89964
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations3.json/const-style-east-const--0048a2a7a881/quicktype.hpp
@@ -0,0 +1,3712 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, std::shared_ptr<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(json const & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, std::optional<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(json const & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(json const & j, char const * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(json const & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    class JurorClass {
+        public:
+        JurorClass() = default;
+        virtual ~JurorClass() = default;
+
+        private:
+        nlohmann::json adipsy;
+        nlohmann::json auxiliator;
+        nlohmann::json benda;
+        nlohmann::json benjamin;
+        nlohmann::json brandling;
+        nlohmann::json epicurishly;
+        nlohmann::json eremochaetous;
+        nlohmann::json marten;
+        nlohmann::json monocline;
+        nlohmann::json olea;
+        nlohmann::json palgat;
+        nlohmann::json pennyworth;
+        nlohmann::json pioury;
+        nlohmann::json pragmatistic;
+        nlohmann::json stylelessness;
+        nlohmann::json systematical;
+        nlohmann::json thready;
+        nlohmann::json uncontemporary;
+        nlohmann::json uncouched;
+        nlohmann::json uninhabitedness;
+
+        public:
+        nlohmann::json const & get_adipsy() const { return adipsy; }
+        nlohmann::json & get_mutable_adipsy() { return adipsy; }
+        void set_adipsy(nlohmann::json const & value) { this->adipsy = value; }
+
+        nlohmann::json const & get_auxiliator() const { return auxiliator; }
+        nlohmann::json & get_mutable_auxiliator() { return auxiliator; }
+        void set_auxiliator(nlohmann::json const & value) { this->auxiliator = value; }
+
+        nlohmann::json const & get_benda() const { return benda; }
+        nlohmann::json & get_mutable_benda() { return benda; }
+        void set_benda(nlohmann::json const & value) { this->benda = value; }
+
+        nlohmann::json const & get_benjamin() const { return benjamin; }
+        nlohmann::json & get_mutable_benjamin() { return benjamin; }
+        void set_benjamin(nlohmann::json const & value) { this->benjamin = value; }
+
+        nlohmann::json const & get_brandling() const { return brandling; }
+        nlohmann::json & get_mutable_brandling() { return brandling; }
+        void set_brandling(nlohmann::json const & value) { this->brandling = value; }
+
+        nlohmann::json const & get_epicurishly() const { return epicurishly; }
+        nlohmann::json & get_mutable_epicurishly() { return epicurishly; }
+        void set_epicurishly(nlohmann::json const & value) { this->epicurishly = value; }
+
+        nlohmann::json const & get_eremochaetous() const { return eremochaetous; }
+        nlohmann::json & get_mutable_eremochaetous() { return eremochaetous; }
+        void set_eremochaetous(nlohmann::json const & value) { this->eremochaetous = value; }
+
+        nlohmann::json const & get_marten() const { return marten; }
+        nlohmann::json & get_mutable_marten() { return marten; }
+        void set_marten(nlohmann::json const & value) { this->marten = value; }
+
+        nlohmann::json const & get_monocline() const { return monocline; }
+        nlohmann::json & get_mutable_monocline() { return monocline; }
+        void set_monocline(nlohmann::json const & value) { this->monocline = value; }
+
+        nlohmann::json const & get_olea() const { return olea; }
+        nlohmann::json & get_mutable_olea() { return olea; }
+        void set_olea(nlohmann::json const & value) { this->olea = value; }
+
+        nlohmann::json const & get_palgat() const { return palgat; }
+        nlohmann::json & get_mutable_palgat() { return palgat; }
+        void set_palgat(nlohmann::json const & value) { this->palgat = value; }
+
+        nlohmann::json const & get_pennyworth() const { return pennyworth; }
+        nlohmann::json & get_mutable_pennyworth() { return pennyworth; }
+        void set_pennyworth(nlohmann::json const & value) { this->pennyworth = value; }
+
+        nlohmann::json const & get_pioury() const { return pioury; }
+        nlohmann::json & get_mutable_pioury() { return pioury; }
+        void set_pioury(nlohmann::json const & value) { this->pioury = value; }
+
+        nlohmann::json const & get_pragmatistic() const { return pragmatistic; }
+        nlohmann::json & get_mutable_pragmatistic() { return pragmatistic; }
+        void set_pragmatistic(nlohmann::json const & value) { this->pragmatistic = value; }
+
+        nlohmann::json const & get_stylelessness() const { return stylelessness; }
+        nlohmann::json & get_mutable_stylelessness() { return stylelessness; }
+        void set_stylelessness(nlohmann::json const & value) { this->stylelessness = value; }
+
+        nlohmann::json const & get_systematical() const { return systematical; }
+        nlohmann::json & get_mutable_systematical() { return systematical; }
+        void set_systematical(nlohmann::json const & value) { this->systematical = value; }
+
+        nlohmann::json const & get_thready() const { return thready; }
+        nlohmann::json & get_mutable_thready() { return thready; }
+        void set_thready(nlohmann::json const & value) { this->thready = value; }
+
+        nlohmann::json const & get_uncontemporary() const { return uncontemporary; }
+        nlohmann::json & get_mutable_uncontemporary() { return uncontemporary; }
+        void set_uncontemporary(nlohmann::json const & value) { this->uncontemporary = value; }
+
+        nlohmann::json const & get_uncouched() const { return uncouched; }
+        nlohmann::json & get_mutable_uncouched() { return uncouched; }
+        void set_uncouched(nlohmann::json const & value) { this->uncouched = value; }
+
+        nlohmann::json const & get_uninhabitedness() const { return uninhabitedness; }
+        nlohmann::json & get_mutable_uninhabitedness() { return uninhabitedness; }
+        void set_uninhabitedness(nlohmann::json const & value) { this->uninhabitedness = value; }
+    };
+
+    using JurorElement = std::variant<bool, JurorClass>;
+
+    using Kongoni = std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>;
+
+    class LadronismClass {
+        public:
+        LadronismClass() = default;
+        virtual ~LadronismClass() = default;
+
+        private:
+        nlohmann::json acclaimer;
+        nlohmann::json achree;
+        nlohmann::json base;
+        nlohmann::json conundrumize;
+        nlohmann::json degerminator;
+        nlohmann::json describable;
+        nlohmann::json exasperatedly;
+        nlohmann::json heroine;
+        nlohmann::json indazin;
+        nlohmann::json luteous;
+        nlohmann::json papular;
+        nlohmann::json pritch;
+        nlohmann::json prodenia;
+        nlohmann::json seege;
+        nlohmann::json shopgirl;
+        nlohmann::json tragedietta;
+        nlohmann::json unsparse;
+        nlohmann::json uplook;
+        nlohmann::json vermiformis;
+        nlohmann::json whafabout;
+
+        public:
+        nlohmann::json const & get_acclaimer() const { return acclaimer; }
+        nlohmann::json & get_mutable_acclaimer() { return acclaimer; }
+        void set_acclaimer(nlohmann::json const & value) { this->acclaimer = value; }
+
+        nlohmann::json const & get_achree() const { return achree; }
+        nlohmann::json & get_mutable_achree() { return achree; }
+        void set_achree(nlohmann::json const & value) { this->achree = value; }
+
+        nlohmann::json const & get_base() const { return base; }
+        nlohmann::json & get_mutable_base() { return base; }
+        void set_base(nlohmann::json const & value) { this->base = value; }
+
+        nlohmann::json const & get_conundrumize() const { return conundrumize; }
+        nlohmann::json & get_mutable_conundrumize() { return conundrumize; }
+        void set_conundrumize(nlohmann::json const & value) { this->conundrumize = value; }
+
+        nlohmann::json const & get_degerminator() const { return degerminator; }
+        nlohmann::json & get_mutable_degerminator() { return degerminator; }
+        void set_degerminator(nlohmann::json const & value) { this->degerminator = value; }
+
+        nlohmann::json const & get_describable() const { return describable; }
+        nlohmann::json & get_mutable_describable() { return describable; }
+        void set_describable(nlohmann::json const & value) { this->describable = value; }
+
+        nlohmann::json const & get_exasperatedly() const { return exasperatedly; }
+        nlohmann::json & get_mutable_exasperatedly() { return exasperatedly; }
+        void set_exasperatedly(nlohmann::json const & value) { this->exasperatedly = value; }
+
+        nlohmann::json const & get_heroine() const { return heroine; }
+        nlohmann::json & get_mutable_heroine() { return heroine; }
+        void set_heroine(nlohmann::json const & value) { this->heroine = value; }
+
+        nlohmann::json const & get_indazin() const { return indazin; }
+        nlohmann::json & get_mutable_indazin() { return indazin; }
+        void set_indazin(nlohmann::json const & value) { this->indazin = value; }
+
+        nlohmann::json const & get_luteous() const { return luteous; }
+        nlohmann::json & get_mutable_luteous() { return luteous; }
+        void set_luteous(nlohmann::json const & value) { this->luteous = value; }
+
+        nlohmann::json const & get_papular() const { return papular; }
+        nlohmann::json & get_mutable_papular() { return papular; }
+        void set_papular(nlohmann::json const & value) { this->papular = value; }
+
+        nlohmann::json const & get_pritch() const { return pritch; }
+        nlohmann::json & get_mutable_pritch() { return pritch; }
+        void set_pritch(nlohmann::json const & value) { this->pritch = value; }
+
+        nlohmann::json const & get_prodenia() const { return prodenia; }
+        nlohmann::json & get_mutable_prodenia() { return prodenia; }
+        void set_prodenia(nlohmann::json const & value) { this->prodenia = value; }
+
+        nlohmann::json const & get_seege() const { return seege; }
+        nlohmann::json & get_mutable_seege() { return seege; }
+        void set_seege(nlohmann::json const & value) { this->seege = value; }
+
+        nlohmann::json const & get_shopgirl() const { return shopgirl; }
+        nlohmann::json & get_mutable_shopgirl() { return shopgirl; }
+        void set_shopgirl(nlohmann::json const & value) { this->shopgirl = value; }
+
+        nlohmann::json const & get_tragedietta() const { return tragedietta; }
+        nlohmann::json & get_mutable_tragedietta() { return tragedietta; }
+        void set_tragedietta(nlohmann::json const & value) { this->tragedietta = value; }
+
+        nlohmann::json const & get_unsparse() const { return unsparse; }
+        nlohmann::json & get_mutable_unsparse() { return unsparse; }
+        void set_unsparse(nlohmann::json const & value) { this->unsparse = value; }
+
+        nlohmann::json const & get_uplook() const { return uplook; }
+        nlohmann::json & get_mutable_uplook() { return uplook; }
+        void set_uplook(nlohmann::json const & value) { this->uplook = value; }
+
+        nlohmann::json const & get_vermiformis() const { return vermiformis; }
+        nlohmann::json & get_mutable_vermiformis() { return vermiformis; }
+        void set_vermiformis(nlohmann::json const & value) { this->vermiformis = value; }
+
+        nlohmann::json const & get_whafabout() const { return whafabout; }
+        nlohmann::json & get_mutable_whafabout() { return whafabout; }
+        void set_whafabout(nlohmann::json const & value) { this->whafabout = value; }
+    };
+
+    using LadronismElement = std::variant<LadronismClass, double, std::string>;
+
+    class LandlubberlyClass {
+        public:
+        LandlubberlyClass() = default;
+        virtual ~LandlubberlyClass() = default;
+
+        private:
+        nlohmann::json acropoleis;
+        nlohmann::json aminate;
+        nlohmann::json amyraldism;
+        nlohmann::json bipenniform;
+        nlohmann::json bugre;
+        nlohmann::json calycule;
+        nlohmann::json caoutchouc;
+        nlohmann::json disprover;
+        nlohmann::json fitroot;
+        nlohmann::json fulgently;
+        nlohmann::json kickup;
+        nlohmann::json laevoversion;
+        nlohmann::json moter;
+        nlohmann::json objectivity;
+        nlohmann::json posterity;
+        nlohmann::json postnuptial;
+        nlohmann::json precedentary;
+        nlohmann::json saddling;
+        nlohmann::json subcurrent;
+        nlohmann::json unrecriminative;
+
+        public:
+        nlohmann::json const & get_acropoleis() const { return acropoleis; }
+        nlohmann::json & get_mutable_acropoleis() { return acropoleis; }
+        void set_acropoleis(nlohmann::json const & value) { this->acropoleis = value; }
+
+        nlohmann::json const & get_aminate() const { return aminate; }
+        nlohmann::json & get_mutable_aminate() { return aminate; }
+        void set_aminate(nlohmann::json const & value) { this->aminate = value; }
+
+        nlohmann::json const & get_amyraldism() const { return amyraldism; }
+        nlohmann::json & get_mutable_amyraldism() { return amyraldism; }
+        void set_amyraldism(nlohmann::json const & value) { this->amyraldism = value; }
+
+        nlohmann::json const & get_bipenniform() const { return bipenniform; }
+        nlohmann::json & get_mutable_bipenniform() { return bipenniform; }
+        void set_bipenniform(nlohmann::json const & value) { this->bipenniform = value; }
+
+        nlohmann::json const & get_bugre() const { return bugre; }
+        nlohmann::json & get_mutable_bugre() { return bugre; }
+        void set_bugre(nlohmann::json const & value) { this->bugre = value; }
+
+        nlohmann::json const & get_calycule() const { return calycule; }
+        nlohmann::json & get_mutable_calycule() { return calycule; }
+        void set_calycule(nlohmann::json const & value) { this->calycule = value; }
+
+        nlohmann::json const & get_caoutchouc() const { return caoutchouc; }
+        nlohmann::json & get_mutable_caoutchouc() { return caoutchouc; }
+        void set_caoutchouc(nlohmann::json const & value) { this->caoutchouc = value; }
+
+        nlohmann::json const & get_disprover() const { return disprover; }
+        nlohmann::json & get_mutable_disprover() { return disprover; }
+        void set_disprover(nlohmann::json const & value) { this->disprover = value; }
+
+        nlohmann::json const & get_fitroot() const { return fitroot; }
+        nlohmann::json & get_mutable_fitroot() { return fitroot; }
+        void set_fitroot(nlohmann::json const & value) { this->fitroot = value; }
+
+        nlohmann::json const & get_fulgently() const { return fulgently; }
+        nlohmann::json & get_mutable_fulgently() { return fulgently; }
+        void set_fulgently(nlohmann::json const & value) { this->fulgently = value; }
+
+        nlohmann::json const & get_kickup() const { return kickup; }
+        nlohmann::json & get_mutable_kickup() { return kickup; }
+        void set_kickup(nlohmann::json const & value) { this->kickup = value; }
+
+        nlohmann::json const & get_laevoversion() const { return laevoversion; }
+        nlohmann::json & get_mutable_laevoversion() { return laevoversion; }
+        void set_laevoversion(nlohmann::json const & value) { this->laevoversion = value; }
+
+        nlohmann::json const & get_moter() const { return moter; }
+        nlohmann::json & get_mutable_moter() { return moter; }
+        void set_moter(nlohmann::json const & value) { this->moter = value; }
+
+        nlohmann::json const & get_objectivity() const { return objectivity; }
+        nlohmann::json & get_mutable_objectivity() { return objectivity; }
+        void set_objectivity(nlohmann::json const & value) { this->objectivity = value; }
+
+        nlohmann::json const & get_posterity() const { return posterity; }
+        nlohmann::json & get_mutable_posterity() { return posterity; }
+        void set_posterity(nlohmann::json const & value) { this->posterity = value; }
+
+        nlohmann::json const & get_postnuptial() const { return postnuptial; }
+        nlohmann::json & get_mutable_postnuptial() { return postnuptial; }
+        void set_postnuptial(nlohmann::json const & value) { this->postnuptial = value; }
+
+        nlohmann::json const & get_precedentary() const { return precedentary; }
+        nlohmann::json & get_mutable_precedentary() { return precedentary; }
+        void set_precedentary(nlohmann::json const & value) { this->precedentary = value; }
+
+        nlohmann::json const & get_saddling() const { return saddling; }
+        nlohmann::json & get_mutable_saddling() { return saddling; }
+        void set_saddling(nlohmann::json const & value) { this->saddling = value; }
+
+        nlohmann::json const & get_subcurrent() const { return subcurrent; }
+        nlohmann::json & get_mutable_subcurrent() { return subcurrent; }
+        void set_subcurrent(nlohmann::json const & value) { this->subcurrent = value; }
+
+        nlohmann::json const & get_unrecriminative() const { return unrecriminative; }
+        nlohmann::json & get_mutable_unrecriminative() { return unrecriminative; }
+        void set_unrecriminative(nlohmann::json const & value) { this->unrecriminative = value; }
+    };
+
+    using LandlubberlyElement = std::variant<bool, LandlubberlyClass, int64_t>;
+
+    using Listener = std::variant<std::vector<nlohmann::json>, int64_t>;
+
+    class LupusClass {
+        public:
+        LupusClass() = default;
+        virtual ~LupusClass() = default;
+
+        private:
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chlorioninae;
+        std::optional<int64_t> corvinae;
+        std::optional<int64_t> crassina;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> exiguity;
+        std::optional<int64_t> farcist;
+        std::optional<int64_t> holographical;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> ichthyophagan;
+        std::optional<int64_t> implacable;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> outshiner;
+        std::optional<int64_t> overweather;
+        std::optional<int64_t> protonegroid;
+        std::optional<int64_t> shallowish;
+        std::optional<int64_t> snoke;
+        std::optional<int64_t> snout;
+        std::optional<int64_t> surveillance;
+        std::optional<int64_t> threshingtime;
+        std::optional<int64_t> thysanocarpus;
+        std::optional<int64_t> unsignificantly;
+        std::optional<int64_t> unsnap;
+        std::optional<int64_t> vendible;
+
+        public:
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_chlorioninae() const { return chlorioninae; }
+        std::optional<int64_t> & get_mutable_chlorioninae() { return chlorioninae; }
+        void set_chlorioninae(std::optional<int64_t> const & value) { this->chlorioninae = value; }
+
+        std::optional<int64_t> const & get_corvinae() const { return corvinae; }
+        std::optional<int64_t> & get_mutable_corvinae() { return corvinae; }
+        void set_corvinae(std::optional<int64_t> const & value) { this->corvinae = value; }
+
+        std::optional<int64_t> const & get_crassina() const { return crassina; }
+        std::optional<int64_t> & get_mutable_crassina() { return crassina; }
+        void set_crassina(std::optional<int64_t> const & value) { this->crassina = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_exiguity() const { return exiguity; }
+        std::optional<int64_t> & get_mutable_exiguity() { return exiguity; }
+        void set_exiguity(std::optional<int64_t> const & value) { this->exiguity = value; }
+
+        std::optional<int64_t> const & get_farcist() const { return farcist; }
+        std::optional<int64_t> & get_mutable_farcist() { return farcist; }
+        void set_farcist(std::optional<int64_t> const & value) { this->farcist = value; }
+
+        std::optional<int64_t> const & get_holographical() const { return holographical; }
+        std::optional<int64_t> & get_mutable_holographical() { return holographical; }
+        void set_holographical(std::optional<int64_t> const & value) { this->holographical = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_ichthyophagan() const { return ichthyophagan; }
+        std::optional<int64_t> & get_mutable_ichthyophagan() { return ichthyophagan; }
+        void set_ichthyophagan(std::optional<int64_t> const & value) { this->ichthyophagan = value; }
+
+        std::optional<int64_t> const & get_implacable() const { return implacable; }
+        std::optional<int64_t> & get_mutable_implacable() { return implacable; }
+        void set_implacable(std::optional<int64_t> const & value) { this->implacable = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_outshiner() const { return outshiner; }
+        std::optional<int64_t> & get_mutable_outshiner() { return outshiner; }
+        void set_outshiner(std::optional<int64_t> const & value) { this->outshiner = value; }
+
+        std::optional<int64_t> const & get_overweather() const { return overweather; }
+        std::optional<int64_t> & get_mutable_overweather() { return overweather; }
+        void set_overweather(std::optional<int64_t> const & value) { this->overweather = value; }
+
+        std::optional<int64_t> const & get_protonegroid() const { return protonegroid; }
+        std::optional<int64_t> & get_mutable_protonegroid() { return protonegroid; }
+        void set_protonegroid(std::optional<int64_t> const & value) { this->protonegroid = value; }
+
+        std::optional<int64_t> const & get_shallowish() const { return shallowish; }
+        std::optional<int64_t> & get_mutable_shallowish() { return shallowish; }
+        void set_shallowish(std::optional<int64_t> const & value) { this->shallowish = value; }
+
+        std::optional<int64_t> const & get_snoke() const { return snoke; }
+        std::optional<int64_t> & get_mutable_snoke() { return snoke; }
+        void set_snoke(std::optional<int64_t> const & value) { this->snoke = value; }
+
+        std::optional<int64_t> const & get_snout() const { return snout; }
+        std::optional<int64_t> & get_mutable_snout() { return snout; }
+        void set_snout(std::optional<int64_t> const & value) { this->snout = value; }
+
+        std::optional<int64_t> const & get_surveillance() const { return surveillance; }
+        std::optional<int64_t> & get_mutable_surveillance() { return surveillance; }
+        void set_surveillance(std::optional<int64_t> const & value) { this->surveillance = value; }
+
+        std::optional<int64_t> const & get_threshingtime() const { return threshingtime; }
+        std::optional<int64_t> & get_mutable_threshingtime() { return threshingtime; }
+        void set_threshingtime(std::optional<int64_t> const & value) { this->threshingtime = value; }
+
+        std::optional<int64_t> const & get_thysanocarpus() const { return thysanocarpus; }
+        std::optional<int64_t> & get_mutable_thysanocarpus() { return thysanocarpus; }
+        void set_thysanocarpus(std::optional<int64_t> const & value) { this->thysanocarpus = value; }
+
+        std::optional<int64_t> const & get_unsignificantly() const { return unsignificantly; }
+        std::optional<int64_t> & get_mutable_unsignificantly() { return unsignificantly; }
+        void set_unsignificantly(std::optional<int64_t> const & value) { this->unsignificantly = value; }
+
+        std::optional<int64_t> const & get_unsnap() const { return unsnap; }
+        std::optional<int64_t> & get_mutable_unsnap() { return unsnap; }
+        void set_unsnap(std::optional<int64_t> const & value) { this->unsnap = value; }
+
+        std::optional<int64_t> const & get_vendible() const { return vendible; }
+        std::optional<int64_t> & get_mutable_vendible() { return vendible; }
+        void set_vendible(std::optional<int64_t> const & value) { this->vendible = value; }
+    };
+
+    using LupusElement = std::variant<LupusClass, int64_t>;
+
+    class Maslin {
+        public:
+        Maslin() = default;
+        virtual ~Maslin() = default;
+
+        private:
+        std::optional<int64_t> alicant;
+        nlohmann::json antiatonement;
+        std::optional<int64_t> anticorrosive;
+        nlohmann::json aphidozer;
+        nlohmann::json bakuninist;
+        std::optional<int64_t> be;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chub;
+        std::optional<int64_t> cuprosilicon;
+        std::optional<int64_t> curtailedly;
+        std::optional<int64_t> dellenite;
+        std::optional<int64_t> dimitry;
+        std::optional<std::string> disdiapason;
+        nlohmann::json edifying;
+        std::optional<int64_t> ethmoiditis;
+        nlohmann::json gastralgy;
+        std::optional<int64_t> goatherd;
+        std::optional<int64_t> hammerdress;
+        nlohmann::json hangfire;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> lacunosity;
+        nlohmann::json longiloquence;
+        std::optional<int64_t> mameliere;
+        nlohmann::json motherless;
+        nlohmann::json nonbookish;
+        nlohmann::json noncorrodible;
+        nlohmann::json nonsensicality;
+        std::optional<int64_t> oafishly;
+        nlohmann::json pfund;
+        nlohmann::json preadvisory;
+        nlohmann::json retroflexed;
+        std::optional<int64_t> saccharulmic;
+        std::optional<int64_t> scowlful;
+        nlohmann::json secluded;
+        nlohmann::json slackage;
+        std::optional<int64_t> sphaeridial;
+        nlohmann::json spondulics;
+        std::optional<int64_t> subsecive;
+        nlohmann::json swellmobsman;
+        std::optional<int64_t> trachyglossate;
+        nlohmann::json trialogue;
+        std::optional<int64_t> unassuaged;
+        nlohmann::json ungross;
+        nlohmann::json unjudiciously;
+
+        public:
+        std::optional<int64_t> const & get_alicant() const { return alicant; }
+        std::optional<int64_t> & get_mutable_alicant() { return alicant; }
+        void set_alicant(std::optional<int64_t> const & value) { this->alicant = value; }
+
+        nlohmann::json const & get_antiatonement() const { return antiatonement; }
+        nlohmann::json & get_mutable_antiatonement() { return antiatonement; }
+        void set_antiatonement(nlohmann::json const & value) { this->antiatonement = value; }
+
+        std::optional<int64_t> const & get_anticorrosive() const { return anticorrosive; }
+        std::optional<int64_t> & get_mutable_anticorrosive() { return anticorrosive; }
+        void set_anticorrosive(std::optional<int64_t> const & value) { this->anticorrosive = value; }
+
+        nlohmann::json const & get_aphidozer() const { return aphidozer; }
+        nlohmann::json & get_mutable_aphidozer() { return aphidozer; }
+        void set_aphidozer(nlohmann::json const & value) { this->aphidozer = value; }
+
+        nlohmann::json const & get_bakuninist() const { return bakuninist; }
+        nlohmann::json & get_mutable_bakuninist() { return bakuninist; }
+        void set_bakuninist(nlohmann::json const & value) { this->bakuninist = value; }
+
+        std::optional<int64_t> const & get_be() const { return be; }
+        std::optional<int64_t> & get_mutable_be() { return be; }
+        void set_be(std::optional<int64_t> const & value) { this->be = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_chub() const { return chub; }
+        std::optional<int64_t> & get_mutable_chub() { return chub; }
+        void set_chub(std::optional<int64_t> const & value) { this->chub = value; }
+
+        std::optional<int64_t> const & get_cuprosilicon() const { return cuprosilicon; }
+        std::optional<int64_t> & get_mutable_cuprosilicon() { return cuprosilicon; }
+        void set_cuprosilicon(std::optional<int64_t> const & value) { this->cuprosilicon = value; }
+
+        std::optional<int64_t> const & get_curtailedly() const { return curtailedly; }
+        std::optional<int64_t> & get_mutable_curtailedly() { return curtailedly; }
+        void set_curtailedly(std::optional<int64_t> const & value) { this->curtailedly = value; }
+
+        std::optional<int64_t> const & get_dellenite() const { return dellenite; }
+        std::optional<int64_t> & get_mutable_dellenite() { return dellenite; }
+        void set_dellenite(std::optional<int64_t> const & value) { this->dellenite = value; }
+
+        std::optional<int64_t> const & get_dimitry() const { return dimitry; }
+        std::optional<int64_t> & get_mutable_dimitry() { return dimitry; }
+        void set_dimitry(std::optional<int64_t> const & value) { this->dimitry = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_edifying() const { return edifying; }
+        nlohmann::json & get_mutable_edifying() { return edifying; }
+        void set_edifying(nlohmann::json const & value) { this->edifying = value; }
+
+        std::optional<int64_t> const & get_ethmoiditis() const { return ethmoiditis; }
+        std::optional<int64_t> & get_mutable_ethmoiditis() { return ethmoiditis; }
+        void set_ethmoiditis(std::optional<int64_t> const & value) { this->ethmoiditis = value; }
+
+        nlohmann::json const & get_gastralgy() const { return gastralgy; }
+        nlohmann::json & get_mutable_gastralgy() { return gastralgy; }
+        void set_gastralgy(nlohmann::json const & value) { this->gastralgy = value; }
+
+        std::optional<int64_t> const & get_goatherd() const { return goatherd; }
+        std::optional<int64_t> & get_mutable_goatherd() { return goatherd; }
+        void set_goatherd(std::optional<int64_t> const & value) { this->goatherd = value; }
+
+        std::optional<int64_t> const & get_hammerdress() const { return hammerdress; }
+        std::optional<int64_t> & get_mutable_hammerdress() { return hammerdress; }
+        void set_hammerdress(std::optional<int64_t> const & value) { this->hammerdress = value; }
+
+        nlohmann::json const & get_hangfire() const { return hangfire; }
+        nlohmann::json & get_mutable_hangfire() { return hangfire; }
+        void set_hangfire(nlohmann::json const & value) { this->hangfire = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_lacunosity() const { return lacunosity; }
+        std::optional<int64_t> & get_mutable_lacunosity() { return lacunosity; }
+        void set_lacunosity(std::optional<int64_t> const & value) { this->lacunosity = value; }
+
+        nlohmann::json const & get_longiloquence() const { return longiloquence; }
+        nlohmann::json & get_mutable_longiloquence() { return longiloquence; }
+        void set_longiloquence(nlohmann::json const & value) { this->longiloquence = value; }
+
+        std::optional<int64_t> const & get_mameliere() const { return mameliere; }
+        std::optional<int64_t> & get_mutable_mameliere() { return mameliere; }
+        void set_mameliere(std::optional<int64_t> const & value) { this->mameliere = value; }
+
+        nlohmann::json const & get_motherless() const { return motherless; }
+        nlohmann::json & get_mutable_motherless() { return motherless; }
+        void set_motherless(nlohmann::json const & value) { this->motherless = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_noncorrodible() const { return noncorrodible; }
+        nlohmann::json & get_mutable_noncorrodible() { return noncorrodible; }
+        void set_noncorrodible(nlohmann::json const & value) { this->noncorrodible = value; }
+
+        nlohmann::json const & get_nonsensicality() const { return nonsensicality; }
+        nlohmann::json & get_mutable_nonsensicality() { return nonsensicality; }
+        void set_nonsensicality(nlohmann::json const & value) { this->nonsensicality = value; }
+
+        std::optional<int64_t> const & get_oafishly() const { return oafishly; }
+        std::optional<int64_t> & get_mutable_oafishly() { return oafishly; }
+        void set_oafishly(std::optional<int64_t> const & value) { this->oafishly = value; }
+
+        nlohmann::json const & get_pfund() const { return pfund; }
+        nlohmann::json & get_mutable_pfund() { return pfund; }
+        void set_pfund(nlohmann::json const & value) { this->pfund = value; }
+
+        nlohmann::json const & get_preadvisory() const { return preadvisory; }
+        nlohmann::json & get_mutable_preadvisory() { return preadvisory; }
+        void set_preadvisory(nlohmann::json const & value) { this->preadvisory = value; }
+
+        nlohmann::json const & get_retroflexed() const { return retroflexed; }
+        nlohmann::json & get_mutable_retroflexed() { return retroflexed; }
+        void set_retroflexed(nlohmann::json const & value) { this->retroflexed = value; }
+
+        std::optional<int64_t> const & get_saccharulmic() const { return saccharulmic; }
+        std::optional<int64_t> & get_mutable_saccharulmic() { return saccharulmic; }
+        void set_saccharulmic(std::optional<int64_t> const & value) { this->saccharulmic = value; }
+
+        std::optional<int64_t> const & get_scowlful() const { return scowlful; }
+        std::optional<int64_t> & get_mutable_scowlful() { return scowlful; }
+        void set_scowlful(std::optional<int64_t> const & value) { this->scowlful = value; }
+
+        nlohmann::json const & get_secluded() const { return secluded; }
+        nlohmann::json & get_mutable_secluded() { return secluded; }
+        void set_secluded(nlohmann::json const & value) { this->secluded = value; }
+
+        nlohmann::json const & get_slackage() const { return slackage; }
+        nlohmann::json & get_mutable_slackage() { return slackage; }
+        void set_slackage(nlohmann::json const & value) { this->slackage = value; }
+
+        std::optional<int64_t> const & get_sphaeridial() const { return sphaeridial; }
+        std::optional<int64_t> & get_mutable_sphaeridial() { return sphaeridial; }
+        void set_sphaeridial(std::optional<int64_t> const & value) { this->sphaeridial = value; }
+
+        nlohmann::json const & get_spondulics() const { return spondulics; }
+        nlohmann::json & get_mutable_spondulics() { return spondulics; }
+        void set_spondulics(nlohmann::json const & value) { this->spondulics = value; }
+
+        std::optional<int64_t> const & get_subsecive() const { return subsecive; }
+        std::optional<int64_t> & get_mutable_subsecive() { return subsecive; }
+        void set_subsecive(std::optional<int64_t> const & value) { this->subsecive = value; }
+
+        nlohmann::json const & get_swellmobsman() const { return swellmobsman; }
+        nlohmann::json & get_mutable_swellmobsman() { return swellmobsman; }
+        void set_swellmobsman(nlohmann::json const & value) { this->swellmobsman = value; }
+
+        std::optional<int64_t> const & get_trachyglossate() const { return trachyglossate; }
+        std::optional<int64_t> & get_mutable_trachyglossate() { return trachyglossate; }
+        void set_trachyglossate(std::optional<int64_t> const & value) { this->trachyglossate = value; }
+
+        nlohmann::json const & get_trialogue() const { return trialogue; }
+        nlohmann::json & get_mutable_trialogue() { return trialogue; }
+        void set_trialogue(nlohmann::json const & value) { this->trialogue = value; }
+
+        std::optional<int64_t> const & get_unassuaged() const { return unassuaged; }
+        std::optional<int64_t> & get_mutable_unassuaged() { return unassuaged; }
+        void set_unassuaged(std::optional<int64_t> const & value) { this->unassuaged = value; }
+
+        nlohmann::json const & get_ungross() const { return ungross; }
+        nlohmann::json & get_mutable_ungross() { return ungross; }
+        void set_ungross(nlohmann::json const & value) { this->ungross = value; }
+
+        nlohmann::json const & get_unjudiciously() const { return unjudiciously; }
+        nlohmann::json & get_mutable_unjudiciously() { return unjudiciously; }
+        void set_unjudiciously(nlohmann::json const & value) { this->unjudiciously = value; }
+    };
+
+    class MonaziteClass {
+        public:
+        MonaziteClass() = default;
+        virtual ~MonaziteClass() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        double const & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(double const & value) { this->catharticalness = value; }
+
+        int64_t const & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(int64_t const & value) { this->chirotherium = value; }
+
+        std::string const & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::string const & value) { this->disdiapason = value; }
+
+        bool const & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(bool const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+    };
+
+    using MonaziteElement = std::variant<MonaziteClass, double>;
+
+    using Monoliteral = std::variant<std::vector<nlohmann::json>, bool>;
+
+    class MonotheisticallyClass {
+        public:
+        MonotheisticallyClass() = default;
+        virtual ~MonotheisticallyClass() = default;
+
+        private:
+        nlohmann::json blaspheme;
+        std::optional<double> catharticalness;
+        nlohmann::json celiosalpingectomy;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json consummativeness;
+        std::optional<std::string> disdiapason;
+        nlohmann::json egestive;
+        nlohmann::json enchylema;
+        nlohmann::json gasconade;
+        nlohmann::json holidayer;
+        std::optional<bool> homocerc;
+        nlohmann::json intuitionalism;
+        nlohmann::json lophiostomate;
+        nlohmann::json nonbookish;
+        nlohmann::json nonvolition;
+        nlohmann::json palatableness;
+        nlohmann::json pimpery;
+        nlohmann::json previolation;
+        nlohmann::json reconveyance;
+        nlohmann::json registership;
+        nlohmann::json rhyacolite;
+        nlohmann::json smithereens;
+        nlohmann::json superedification;
+        nlohmann::json trust;
+        nlohmann::json whitestone;
+
+        public:
+        nlohmann::json const & get_blaspheme() const { return blaspheme; }
+        nlohmann::json & get_mutable_blaspheme() { return blaspheme; }
+        void set_blaspheme(nlohmann::json const & value) { this->blaspheme = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        nlohmann::json const & get_celiosalpingectomy() const { return celiosalpingectomy; }
+        nlohmann::json & get_mutable_celiosalpingectomy() { return celiosalpingectomy; }
+        void set_celiosalpingectomy(nlohmann::json const & value) { this->celiosalpingectomy = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        nlohmann::json const & get_consummativeness() const { return consummativeness; }
+        nlohmann::json & get_mutable_consummativeness() { return consummativeness; }
+        void set_consummativeness(nlohmann::json const & value) { this->consummativeness = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_egestive() const { return egestive; }
+        nlohmann::json & get_mutable_egestive() { return egestive; }
+        void set_egestive(nlohmann::json const & value) { this->egestive = value; }
+
+        nlohmann::json const & get_enchylema() const { return enchylema; }
+        nlohmann::json & get_mutable_enchylema() { return enchylema; }
+        void set_enchylema(nlohmann::json const & value) { this->enchylema = value; }
+
+        nlohmann::json const & get_gasconade() const { return gasconade; }
+        nlohmann::json & get_mutable_gasconade() { return gasconade; }
+        void set_gasconade(nlohmann::json const & value) { this->gasconade = value; }
+
+        nlohmann::json const & get_holidayer() const { return holidayer; }
+        nlohmann::json & get_mutable_holidayer() { return holidayer; }
+        void set_holidayer(nlohmann::json const & value) { this->holidayer = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_intuitionalism() const { return intuitionalism; }
+        nlohmann::json & get_mutable_intuitionalism() { return intuitionalism; }
+        void set_intuitionalism(nlohmann::json const & value) { this->intuitionalism = value; }
+
+        nlohmann::json const & get_lophiostomate() const { return lophiostomate; }
+        nlohmann::json & get_mutable_lophiostomate() { return lophiostomate; }
+        void set_lophiostomate(nlohmann::json const & value) { this->lophiostomate = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_nonvolition() const { return nonvolition; }
+        nlohmann::json & get_mutable_nonvolition() { return nonvolition; }
+        void set_nonvolition(nlohmann::json const & value) { this->nonvolition = value; }
+
+        nlohmann::json const & get_palatableness() const { return palatableness; }
+        nlohmann::json & get_mutable_palatableness() { return palatableness; }
+        void set_palatableness(nlohmann::json const & value) { this->palatableness = value; }
+
+        nlohmann::json const & get_pimpery() const { return pimpery; }
+        nlohmann::json & get_mutable_pimpery() { return pimpery; }
+        void set_pimpery(nlohmann::json const & value) { this->pimpery = value; }
+
+        nlohmann::json const & get_previolation() const { return previolation; }
+        nlohmann::json & get_mutable_previolation() { return previolation; }
+        void set_previolation(nlohmann::json const & value) { this->previolation = value; }
+
+        nlohmann::json const & get_reconveyance() const { return reconveyance; }
+        nlohmann::json & get_mutable_reconveyance() { return reconveyance; }
+        void set_reconveyance(nlohmann::json const & value) { this->reconveyance = value; }
+
+        nlohmann::json const & get_registership() const { return registership; }
+        nlohmann::json & get_mutable_registership() { return registership; }
+        void set_registership(nlohmann::json const & value) { this->registership = value; }
+
+        nlohmann::json const & get_rhyacolite() const { return rhyacolite; }
+        nlohmann::json & get_mutable_rhyacolite() { return rhyacolite; }
+        void set_rhyacolite(nlohmann::json const & value) { this->rhyacolite = value; }
+
+        nlohmann::json const & get_smithereens() const { return smithereens; }
+        nlohmann::json & get_mutable_smithereens() { return smithereens; }
+        void set_smithereens(nlohmann::json const & value) { this->smithereens = value; }
+
+        nlohmann::json const & get_superedification() const { return superedification; }
+        nlohmann::json & get_mutable_superedification() { return superedification; }
+        void set_superedification(nlohmann::json const & value) { this->superedification = value; }
+
+        nlohmann::json const & get_trust() const { return trust; }
+        nlohmann::json & get_mutable_trust() { return trust; }
+        void set_trust(nlohmann::json const & value) { this->trust = value; }
+
+        nlohmann::json const & get_whitestone() const { return whitestone; }
+        nlohmann::json & get_mutable_whitestone() { return whitestone; }
+        void set_whitestone(nlohmann::json const & value) { this->whitestone = value; }
+    };
+
+    using MonotheisticallyElement = std::variant<std::vector<nlohmann::json>, MonotheisticallyClass>;
+
+    using Montage = std::variant<std::vector<nlohmann::json>, double, std::string>;
+
+    using Moralness = std::optional<std::variant<std::vector<nlohmann::json>, double>>;
+
+    using Mulishly = std::optional<std::variant<std::vector<int64_t>, double>>;
+
+    using Myoscope = std::variant<std::vector<nlohmann::json>, bool, int64_t>;
+
+    using Neuromastic = std::variant<std::vector<nlohmann::json>, double>;
+
+    class Noncontributing {
+        public:
+        Noncontributing() = default;
+        virtual ~Noncontributing() = default;
+
+        private:
+        std::string estevin;
+        double jolterhead;
+        int64_t sauternes;
+        bool sparsely;
+        nlohmann::json unrequested;
+
+        public:
+        std::string const & get_estevin() const { return estevin; }
+        std::string & get_mutable_estevin() { return estevin; }
+        void set_estevin(std::string const & value) { this->estevin = value; }
+
+        double const & get_jolterhead() const { return jolterhead; }
+        double & get_mutable_jolterhead() { return jolterhead; }
+        void set_jolterhead(double const & value) { this->jolterhead = value; }
+
+        int64_t const & get_sauternes() const { return sauternes; }
+        int64_t & get_mutable_sauternes() { return sauternes; }
+        void set_sauternes(int64_t const & value) { this->sauternes = value; }
+
+        bool const & get_sparsely() const { return sparsely; }
+        bool & get_mutable_sparsely() { return sparsely; }
+        void set_sparsely(bool const & value) { this->sparsely = value; }
+
+        nlohmann::json const & get_unrequested() const { return unrequested; }
+        nlohmann::json & get_mutable_unrequested() { return unrequested; }
+        void set_unrequested(nlohmann::json const & value) { this->unrequested = value; }
+    };
+
+    using Nonnervous = std::variant<bool, int64_t>;
+
+    using Nonvaluation = std::variant<std::vector<nlohmann::json>, bool, double>;
+
+    class OccupationalistClass {
+        public:
+        OccupationalistClass() = default;
+        virtual ~OccupationalistClass() = default;
+
+        private:
+        nlohmann::json beholdable;
+        nlohmann::json brotuliform;
+        nlohmann::json chimakum;
+        nlohmann::json doodler;
+        nlohmann::json emulsin;
+        nlohmann::json fin;
+        nlohmann::json flourishing;
+        nlohmann::json flueless;
+        nlohmann::json furtively;
+        nlohmann::json gritter;
+        nlohmann::json interwish;
+        nlohmann::json monoxylic;
+        nlohmann::json myristic;
+        nlohmann::json nightwear;
+        nlohmann::json peruser;
+        nlohmann::json theoastrological;
+        nlohmann::json thumby;
+        nlohmann::json tingitid;
+        nlohmann::json trailless;
+        nlohmann::json unpocketed;
+
+        public:
+        nlohmann::json const & get_beholdable() const { return beholdable; }
+        nlohmann::json & get_mutable_beholdable() { return beholdable; }
+        void set_beholdable(nlohmann::json const & value) { this->beholdable = value; }
+
+        nlohmann::json const & get_brotuliform() const { return brotuliform; }
+        nlohmann::json & get_mutable_brotuliform() { return brotuliform; }
+        void set_brotuliform(nlohmann::json const & value) { this->brotuliform = value; }
+
+        nlohmann::json const & get_chimakum() const { return chimakum; }
+        nlohmann::json & get_mutable_chimakum() { return chimakum; }
+        void set_chimakum(nlohmann::json const & value) { this->chimakum = value; }
+
+        nlohmann::json const & get_doodler() const { return doodler; }
+        nlohmann::json & get_mutable_doodler() { return doodler; }
+        void set_doodler(nlohmann::json const & value) { this->doodler = value; }
+
+        nlohmann::json const & get_emulsin() const { return emulsin; }
+        nlohmann::json & get_mutable_emulsin() { return emulsin; }
+        void set_emulsin(nlohmann::json const & value) { this->emulsin = value; }
+
+        nlohmann::json const & get_fin() const { return fin; }
+        nlohmann::json & get_mutable_fin() { return fin; }
+        void set_fin(nlohmann::json const & value) { this->fin = value; }
+
+        nlohmann::json const & get_flourishing() const { return flourishing; }
+        nlohmann::json & get_mutable_flourishing() { return flourishing; }
+        void set_flourishing(nlohmann::json const & value) { this->flourishing = value; }
+
+        nlohmann::json const & get_flueless() const { return flueless; }
+        nlohmann::json & get_mutable_flueless() { return flueless; }
+        void set_flueless(nlohmann::json const & value) { this->flueless = value; }
+
+        nlohmann::json const & get_furtively() const { return furtively; }
+        nlohmann::json & get_mutable_furtively() { return furtively; }
+        void set_furtively(nlohmann::json const & value) { this->furtively = value; }
+
+        nlohmann::json const & get_gritter() const { return gritter; }
+        nlohmann::json & get_mutable_gritter() { return gritter; }
+        void set_gritter(nlohmann::json const & value) { this->gritter = value; }
+
+        nlohmann::json const & get_interwish() const { return interwish; }
+        nlohmann::json & get_mutable_interwish() { return interwish; }
+        void set_interwish(nlohmann::json const & value) { this->interwish = value; }
+
+        nlohmann::json const & get_monoxylic() const { return monoxylic; }
+        nlohmann::json & get_mutable_monoxylic() { return monoxylic; }
+        void set_monoxylic(nlohmann::json const & value) { this->monoxylic = value; }
+
+        nlohmann::json const & get_myristic() const { return myristic; }
+        nlohmann::json & get_mutable_myristic() { return myristic; }
+        void set_myristic(nlohmann::json const & value) { this->myristic = value; }
+
+        nlohmann::json const & get_nightwear() const { return nightwear; }
+        nlohmann::json & get_mutable_nightwear() { return nightwear; }
+        void set_nightwear(nlohmann::json const & value) { this->nightwear = value; }
+
+        nlohmann::json const & get_peruser() const { return peruser; }
+        nlohmann::json & get_mutable_peruser() { return peruser; }
+        void set_peruser(nlohmann::json const & value) { this->peruser = value; }
+
+        nlohmann::json const & get_theoastrological() const { return theoastrological; }
+        nlohmann::json & get_mutable_theoastrological() { return theoastrological; }
+        void set_theoastrological(nlohmann::json const & value) { this->theoastrological = value; }
+
+        nlohmann::json const & get_thumby() const { return thumby; }
+        nlohmann::json & get_mutable_thumby() { return thumby; }
+        void set_thumby(nlohmann::json const & value) { this->thumby = value; }
+
+        nlohmann::json const & get_tingitid() const { return tingitid; }
+        nlohmann::json & get_mutable_tingitid() { return tingitid; }
+        void set_tingitid(nlohmann::json const & value) { this->tingitid = value; }
+
+        nlohmann::json const & get_trailless() const { return trailless; }
+        nlohmann::json & get_mutable_trailless() { return trailless; }
+        void set_trailless(nlohmann::json const & value) { this->trailless = value; }
+
+        nlohmann::json const & get_unpocketed() const { return unpocketed; }
+        nlohmann::json & get_mutable_unpocketed() { return unpocketed; }
+        void set_unpocketed(nlohmann::json const & value) { this->unpocketed = value; }
+    };
+
+    using OccupationalistElement = std::optional<std::variant<std::vector<nlohmann::json>, OccupationalistClass>>;
+
+    class OutrivalClass {
+        public:
+        OutrivalClass() = default;
+        virtual ~OutrivalClass() = default;
+
+        private:
+        nlohmann::json adroitly;
+        nlohmann::json bridehood;
+        nlohmann::json castoroides;
+        nlohmann::json czechoslovak;
+        nlohmann::json diagenesis;
+        nlohmann::json dihexahedron;
+        nlohmann::json dopester;
+        nlohmann::json eumerism;
+        nlohmann::json flyness;
+        nlohmann::json fouler;
+        nlohmann::json laudanosine;
+        nlohmann::json lingulidae;
+        nlohmann::json minutary;
+        nlohmann::json mitra;
+        nlohmann::json opisthorchiasis;
+        nlohmann::json pensively;
+        nlohmann::json pubigerous;
+        nlohmann::json rebellious;
+        nlohmann::json recodify;
+        nlohmann::json unpaced;
+
+        public:
+        nlohmann::json const & get_adroitly() const { return adroitly; }
+        nlohmann::json & get_mutable_adroitly() { return adroitly; }
+        void set_adroitly(nlohmann::json const & value) { this->adroitly = value; }
+
+        nlohmann::json const & get_bridehood() const { return bridehood; }
+        nlohmann::json & get_mutable_bridehood() { return bridehood; }
+        void set_bridehood(nlohmann::json const & value) { this->bridehood = value; }
+
+        nlohmann::json const & get_castoroides() const { return castoroides; }
+        nlohmann::json & get_mutable_castoroides() { return castoroides; }
+        void set_castoroides(nlohmann::json const & value) { this->castoroides = value; }
+
+        nlohmann::json const & get_czechoslovak() const { return czechoslovak; }
+        nlohmann::json & get_mutable_czechoslovak() { return czechoslovak; }
+        void set_czechoslovak(nlohmann::json const & value) { this->czechoslovak = value; }
+
+        nlohmann::json const & get_diagenesis() const { return diagenesis; }
+        nlohmann::json & get_mutable_diagenesis() { return diagenesis; }
+        void set_diagenesis(nlohmann::json const & value) { this->diagenesis = value; }
+
+        nlohmann::json const & get_dihexahedron() const { return dihexahedron; }
+        nlohmann::json & get_mutable_dihexahedron() { return dihexahedron; }
+        void set_dihexahedron(nlohmann::json const & value) { this->dihexahedron = value; }
+
+        nlohmann::json const & get_dopester() const { return dopester; }
+        nlohmann::json & get_mutable_dopester() { return dopester; }
+        void set_dopester(nlohmann::json const & value) { this->dopester = value; }
+
+        nlohmann::json const & get_eumerism() const { return eumerism; }
+        nlohmann::json & get_mutable_eumerism() { return eumerism; }
+        void set_eumerism(nlohmann::json const & value) { this->eumerism = value; }
+
+        nlohmann::json const & get_flyness() const { return flyness; }
+        nlohmann::json & get_mutable_flyness() { return flyness; }
+        void set_flyness(nlohmann::json const & value) { this->flyness = value; }
+
+        nlohmann::json const & get_fouler() const { return fouler; }
+        nlohmann::json & get_mutable_fouler() { return fouler; }
+        void set_fouler(nlohmann::json const & value) { this->fouler = value; }
+
+        nlohmann::json const & get_laudanosine() const { return laudanosine; }
+        nlohmann::json & get_mutable_laudanosine() { return laudanosine; }
+        void set_laudanosine(nlohmann::json const & value) { this->laudanosine = value; }
+
+        nlohmann::json const & get_lingulidae() const { return lingulidae; }
+        nlohmann::json & get_mutable_lingulidae() { return lingulidae; }
+        void set_lingulidae(nlohmann::json const & value) { this->lingulidae = value; }
+
+        nlohmann::json const & get_minutary() const { return minutary; }
+        nlohmann::json & get_mutable_minutary() { return minutary; }
+        void set_minutary(nlohmann::json const & value) { this->minutary = value; }
+
+        nlohmann::json const & get_mitra() const { return mitra; }
+        nlohmann::json & get_mutable_mitra() { return mitra; }
+        void set_mitra(nlohmann::json const & value) { this->mitra = value; }
+
+        nlohmann::json const & get_opisthorchiasis() const { return opisthorchiasis; }
+        nlohmann::json & get_mutable_opisthorchiasis() { return opisthorchiasis; }
+        void set_opisthorchiasis(nlohmann::json const & value) { this->opisthorchiasis = value; }
+
+        nlohmann::json const & get_pensively() const { return pensively; }
+        nlohmann::json & get_mutable_pensively() { return pensively; }
+        void set_pensively(nlohmann::json const & value) { this->pensively = value; }
+
+        nlohmann::json const & get_pubigerous() const { return pubigerous; }
+        nlohmann::json & get_mutable_pubigerous() { return pubigerous; }
+        void set_pubigerous(nlohmann::json const & value) { this->pubigerous = value; }
+
+        nlohmann::json const & get_rebellious() const { return rebellious; }
+        nlohmann::json & get_mutable_rebellious() { return rebellious; }
+        void set_rebellious(nlohmann::json const & value) { this->rebellious = value; }
+
+        nlohmann::json const & get_recodify() const { return recodify; }
+        nlohmann::json & get_mutable_recodify() { return recodify; }
+        void set_recodify(nlohmann::json const & value) { this->recodify = value; }
+
+        nlohmann::json const & get_unpaced() const { return unpaced; }
+        nlohmann::json & get_mutable_unpaced() { return unpaced; }
+        void set_unpaced(nlohmann::json const & value) { this->unpaced = value; }
+    };
+
+    using OutrivalElement = std::optional<std::variant<OutrivalClass, double>>;
+
+    using Paleographically = std::variant<double, std::map<std::string, std::optional<int64_t>>>;
+
+    using Pamphletwise = std::variant<int64_t, std::map<std::string, int64_t>, std::string>;
+
+    using Pediatric = std::optional<std::variant<bool, double>>;
+
+    class PiaculumClass {
+        public:
+        PiaculumClass() = default;
+        virtual ~PiaculumClass() = default;
+
+        private:
+        std::optional<int64_t> alada;
+        std::optional<int64_t> amphistomous;
+        std::optional<int64_t> boysenberry;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> decardinalize;
+        std::optional<int64_t> discouragement;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> doitrified;
+        std::optional<int64_t> hexaspermous;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> insinking;
+        std::optional<int64_t> loathfulness;
+        std::optional<int64_t> miasmatical;
+        std::optional<int64_t> neurofibril;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> phonendoscope;
+        std::optional<int64_t> pilferment;
+        std::optional<int64_t> predismissory;
+        std::optional<int64_t> preinscription;
+        std::optional<int64_t> quotative;
+        std::optional<int64_t> sienna;
+        std::optional<int64_t> thorax;
+        std::optional<int64_t> yachting;
+        std::optional<int64_t> zipper;
+
+        public:
+        std::optional<int64_t> const & get_alada() const { return alada; }
+        std::optional<int64_t> & get_mutable_alada() { return alada; }
+        void set_alada(std::optional<int64_t> const & value) { this->alada = value; }
+
+        std::optional<int64_t> const & get_amphistomous() const { return amphistomous; }
+        std::optional<int64_t> & get_mutable_amphistomous() { return amphistomous; }
+        void set_amphistomous(std::optional<int64_t> const & value) { this->amphistomous = value; }
+
+        std::optional<int64_t> const & get_boysenberry() const { return boysenberry; }
+        std::optional<int64_t> & get_mutable_boysenberry() { return boysenberry; }
+        void set_boysenberry(std::optional<int64_t> const & value) { this->boysenberry = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_decardinalize() const { return decardinalize; }
+        std::optional<int64_t> & get_mutable_decardinalize() { return decardinalize; }
+        void set_decardinalize(std::optional<int64_t> const & value) { this->decardinalize = value; }
+
+        std::optional<int64_t> const & get_discouragement() const { return discouragement; }
+        std::optional<int64_t> & get_mutable_discouragement() { return discouragement; }
+        void set_discouragement(std::optional<int64_t> const & value) { this->discouragement = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_doitrified() const { return doitrified; }
+        std::optional<int64_t> & get_mutable_doitrified() { return doitrified; }
+        void set_doitrified(std::optional<int64_t> const & value) { this->doitrified = value; }
+
+        std::optional<int64_t> const & get_hexaspermous() const { return hexaspermous; }
+        std::optional<int64_t> & get_mutable_hexaspermous() { return hexaspermous; }
+        void set_hexaspermous(std::optional<int64_t> const & value) { this->hexaspermous = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_insinking() const { return insinking; }
+        std::optional<int64_t> & get_mutable_insinking() { return insinking; }
+        void set_insinking(std::optional<int64_t> const & value) { this->insinking = value; }
+
+        std::optional<int64_t> const & get_loathfulness() const { return loathfulness; }
+        std::optional<int64_t> & get_mutable_loathfulness() { return loathfulness; }
+        void set_loathfulness(std::optional<int64_t> const & value) { this->loathfulness = value; }
+
+        std::optional<int64_t> const & get_miasmatical() const { return miasmatical; }
+        std::optional<int64_t> & get_mutable_miasmatical() { return miasmatical; }
+        void set_miasmatical(std::optional<int64_t> const & value) { this->miasmatical = value; }
+
+        std::optional<int64_t> const & get_neurofibril() const { return neurofibril; }
+        std::optional<int64_t> & get_mutable_neurofibril() { return neurofibril; }
+        void set_neurofibril(std::optional<int64_t> const & value) { this->neurofibril = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_phonendoscope() const { return phonendoscope; }
+        std::optional<int64_t> & get_mutable_phonendoscope() { return phonendoscope; }
+        void set_phonendoscope(std::optional<int64_t> const & value) { this->phonendoscope = value; }
+
+        std::optional<int64_t> const & get_pilferment() const { return pilferment; }
+        std::optional<int64_t> & get_mutable_pilferment() { return pilferment; }
+        void set_pilferment(std::optional<int64_t> const & value) { this->pilferment = value; }
+
+        std::optional<int64_t> const & get_predismissory() const { return predismissory; }
+        std::optional<int64_t> & get_mutable_predismissory() { return predismissory; }
+        void set_predismissory(std::optional<int64_t> const & value) { this->predismissory = value; }
+
+        std::optional<int64_t> const & get_preinscription() const { return preinscription; }
+        std::optional<int64_t> & get_mutable_preinscription() { return preinscription; }
+        void set_preinscription(std::optional<int64_t> const & value) { this->preinscription = value; }
+
+        std::optional<int64_t> const & get_quotative() const { return quotative; }
+        std::optional<int64_t> & get_mutable_quotative() { return quotative; }
+        void set_quotative(std::optional<int64_t> const & value) { this->quotative = value; }
+
+        std::optional<int64_t> const & get_sienna() const { return sienna; }
+        std::optional<int64_t> & get_mutable_sienna() { return sienna; }
+        void set_sienna(std::optional<int64_t> const & value) { this->sienna = value; }
+
+        std::optional<int64_t> const & get_thorax() const { return thorax; }
+        std::optional<int64_t> & get_mutable_thorax() { return thorax; }
+        void set_thorax(std::optional<int64_t> const & value) { this->thorax = value; }
+
+        std::optional<int64_t> const & get_yachting() const { return yachting; }
+        std::optional<int64_t> & get_mutable_yachting() { return yachting; }
+        void set_yachting(std::optional<int64_t> const & value) { this->yachting = value; }
+
+        std::optional<int64_t> const & get_zipper() const { return zipper; }
+        std::optional<int64_t> & get_mutable_zipper() { return zipper; }
+        void set_zipper(std::optional<int64_t> const & value) { this->zipper = value; }
+    };
+
+    using PiaculumElement = std::variant<PiaculumClass, double>;
+
+    using Piccadilly = std::optional<std::variant<double, std::string>>;
+
+    using Piffler = std::variant<std::vector<nlohmann::json>, MonaziteClass>;
+
+    using Pithful = std::optional<std::variant<bool, int64_t>>;
+
+    using Placuntiti = std::variant<int64_t, std::map<std::string, int64_t>>;
+
+    using Plectopterous = std::variant<double, std::map<std::string, int64_t>>;
+
+    class Pneumocele {
+        public:
+        Pneumocele() = default;
+        virtual ~Pneumocele() = default;
+
+        private:
+        nlohmann::json carbonarism;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json cineolic;
+        nlohmann::json cobbly;
+        nlohmann::json conchyliferous;
+        nlohmann::json congregation;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enterotomy;
+        nlohmann::json entophytal;
+        nlohmann::json fewtrils;
+        nlohmann::json herem;
+        std::optional<bool> homocerc;
+        nlohmann::json koniga;
+        nlohmann::json meticulosity;
+        nlohmann::json micky;
+        nlohmann::json mismarriage;
+        nlohmann::json neurotrophic;
+        nlohmann::json nonbookish;
+        nlohmann::json persuasively;
+        nlohmann::json replaceable;
+        nlohmann::json silex;
+        nlohmann::json taillight;
+        nlohmann::json unjealous;
+        nlohmann::json visitorial;
+
+        public:
+        nlohmann::json const & get_carbonarism() const { return carbonarism; }
+        nlohmann::json & get_mutable_carbonarism() { return carbonarism; }
+        void set_carbonarism(nlohmann::json const & value) { this->carbonarism = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        nlohmann::json const & get_cineolic() const { return cineolic; }
+        nlohmann::json & get_mutable_cineolic() { return cineolic; }
+        void set_cineolic(nlohmann::json const & value) { this->cineolic = value; }
+
+        nlohmann::json const & get_cobbly() const { return cobbly; }
+        nlohmann::json & get_mutable_cobbly() { return cobbly; }
+        void set_cobbly(nlohmann::json const & value) { this->cobbly = value; }
+
+        nlohmann::json const & get_conchyliferous() const { return conchyliferous; }
+        nlohmann::json & get_mutable_conchyliferous() { return conchyliferous; }
+        void set_conchyliferous(nlohmann::json const & value) { this->conchyliferous = value; }
+
+        nlohmann::json const & get_congregation() const { return congregation; }
+        nlohmann::json & get_mutable_congregation() { return congregation; }
+        void set_congregation(nlohmann::json const & value) { this->congregation = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_enterotomy() const { return enterotomy; }
+        nlohmann::json & get_mutable_enterotomy() { return enterotomy; }
+        void set_enterotomy(nlohmann::json const & value) { this->enterotomy = value; }
+
+        nlohmann::json const & get_entophytal() const { return entophytal; }
+        nlohmann::json & get_mutable_entophytal() { return entophytal; }
+        void set_entophytal(nlohmann::json const & value) { this->entophytal = value; }
+
+        nlohmann::json const & get_fewtrils() const { return fewtrils; }
+        nlohmann::json & get_mutable_fewtrils() { return fewtrils; }
+        void set_fewtrils(nlohmann::json const & value) { this->fewtrils = value; }
+
+        nlohmann::json const & get_herem() const { return herem; }
+        nlohmann::json & get_mutable_herem() { return herem; }
+        void set_herem(nlohmann::json const & value) { this->herem = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_koniga() const { return koniga; }
+        nlohmann::json & get_mutable_koniga() { return koniga; }
+        void set_koniga(nlohmann::json const & value) { this->koniga = value; }
+
+        nlohmann::json const & get_meticulosity() const { return meticulosity; }
+        nlohmann::json & get_mutable_meticulosity() { return meticulosity; }
+        void set_meticulosity(nlohmann::json const & value) { this->meticulosity = value; }
+
+        nlohmann::json const & get_micky() const { return micky; }
+        nlohmann::json & get_mutable_micky() { return micky; }
+        void set_micky(nlohmann::json const & value) { this->micky = value; }
+
+        nlohmann::json const & get_mismarriage() const { return mismarriage; }
+        nlohmann::json & get_mutable_mismarriage() { return mismarriage; }
+        void set_mismarriage(nlohmann::json const & value) { this->mismarriage = value; }
+
+        nlohmann::json const & get_neurotrophic() const { return neurotrophic; }
+        nlohmann::json & get_mutable_neurotrophic() { return neurotrophic; }
+        void set_neurotrophic(nlohmann::json const & value) { this->neurotrophic = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_persuasively() const { return persuasively; }
+        nlohmann::json & get_mutable_persuasively() { return persuasively; }
+        void set_persuasively(nlohmann::json const & value) { this->persuasively = value; }
+
+        nlohmann::json const & get_replaceable() const { return replaceable; }
+        nlohmann::json & get_mutable_replaceable() { return replaceable; }
+        void set_replaceable(nlohmann::json const & value) { this->replaceable = value; }
+
+        nlohmann::json const & get_silex() const { return silex; }
+        nlohmann::json & get_mutable_silex() { return silex; }
+        void set_silex(nlohmann::json const & value) { this->silex = value; }
+
+        nlohmann::json const & get_taillight() const { return taillight; }
+        nlohmann::json & get_mutable_taillight() { return taillight; }
+        void set_taillight(nlohmann::json const & value) { this->taillight = value; }
+
+        nlohmann::json const & get_unjealous() const { return unjealous; }
+        nlohmann::json & get_mutable_unjealous() { return unjealous; }
+        void set_unjealous(nlohmann::json const & value) { this->unjealous = value; }
+
+        nlohmann::json const & get_visitorial() const { return visitorial; }
+        nlohmann::json & get_mutable_visitorial() { return visitorial; }
+        void set_visitorial(nlohmann::json const & value) { this->visitorial = value; }
+    };
+
+    using Poliorcetic = std::variant<bool, MonaziteClass>;
+
+    using Poormaster = std::optional<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>;
+
+    class PotwhiskyClass {
+        public:
+        PotwhiskyClass() = default;
+        virtual ~PotwhiskyClass() = default;
+
+        private:
+        nlohmann::json arciform;
+        nlohmann::json cresolin;
+        nlohmann::json disheartener;
+        nlohmann::json disproportionable;
+        nlohmann::json euchorda;
+        nlohmann::json ferryway;
+        nlohmann::json filamentiferous;
+        nlohmann::json flemish;
+        nlohmann::json forgainst;
+        nlohmann::json grainering;
+        nlohmann::json irrevoluble;
+        nlohmann::json kindredship;
+        nlohmann::json pinguitudinous;
+        nlohmann::json simpletonic;
+        nlohmann::json singsong;
+        nlohmann::json submergement;
+        nlohmann::json supraoesophagal;
+        nlohmann::json thrashel;
+        nlohmann::json tyremesis;
+        nlohmann::json yoruba;
+
+        public:
+        nlohmann::json const & get_arciform() const { return arciform; }
+        nlohmann::json & get_mutable_arciform() { return arciform; }
+        void set_arciform(nlohmann::json const & value) { this->arciform = value; }
+
+        nlohmann::json const & get_cresolin() const { return cresolin; }
+        nlohmann::json & get_mutable_cresolin() { return cresolin; }
+        void set_cresolin(nlohmann::json const & value) { this->cresolin = value; }
+
+        nlohmann::json const & get_disheartener() const { return disheartener; }
+        nlohmann::json & get_mutable_disheartener() { return disheartener; }
+        void set_disheartener(nlohmann::json const & value) { this->disheartener = value; }
+
+        nlohmann::json const & get_disproportionable() const { return disproportionable; }
+        nlohmann::json & get_mutable_disproportionable() { return disproportionable; }
+        void set_disproportionable(nlohmann::json const & value) { this->disproportionable = value; }
+
+        nlohmann::json const & get_euchorda() const { return euchorda; }
+        nlohmann::json & get_mutable_euchorda() { return euchorda; }
+        void set_euchorda(nlohmann::json const & value) { this->euchorda = value; }
+
+        nlohmann::json const & get_ferryway() const { return ferryway; }
+        nlohmann::json & get_mutable_ferryway() { return ferryway; }
+        void set_ferryway(nlohmann::json const & value) { this->ferryway = value; }
+
+        nlohmann::json const & get_filamentiferous() const { return filamentiferous; }
+        nlohmann::json & get_mutable_filamentiferous() { return filamentiferous; }
+        void set_filamentiferous(nlohmann::json const & value) { this->filamentiferous = value; }
+
+        nlohmann::json const & get_flemish() const { return flemish; }
+        nlohmann::json & get_mutable_flemish() { return flemish; }
+        void set_flemish(nlohmann::json const & value) { this->flemish = value; }
+
+        nlohmann::json const & get_forgainst() const { return forgainst; }
+        nlohmann::json & get_mutable_forgainst() { return forgainst; }
+        void set_forgainst(nlohmann::json const & value) { this->forgainst = value; }
+
+        nlohmann::json const & get_grainering() const { return grainering; }
+        nlohmann::json & get_mutable_grainering() { return grainering; }
+        void set_grainering(nlohmann::json const & value) { this->grainering = value; }
+
+        nlohmann::json const & get_irrevoluble() const { return irrevoluble; }
+        nlohmann::json & get_mutable_irrevoluble() { return irrevoluble; }
+        void set_irrevoluble(nlohmann::json const & value) { this->irrevoluble = value; }
+
+        nlohmann::json const & get_kindredship() const { return kindredship; }
+        nlohmann::json & get_mutable_kindredship() { return kindredship; }
+        void set_kindredship(nlohmann::json const & value) { this->kindredship = value; }
+
+        nlohmann::json const & get_pinguitudinous() const { return pinguitudinous; }
+        nlohmann::json & get_mutable_pinguitudinous() { return pinguitudinous; }
+        void set_pinguitudinous(nlohmann::json const & value) { this->pinguitudinous = value; }
+
+        nlohmann::json const & get_simpletonic() const { return simpletonic; }
+        nlohmann::json & get_mutable_simpletonic() { return simpletonic; }
+        void set_simpletonic(nlohmann::json const & value) { this->simpletonic = value; }
+
+        nlohmann::json const & get_singsong() const { return singsong; }
+        nlohmann::json & get_mutable_singsong() { return singsong; }
+        void set_singsong(nlohmann::json const & value) { this->singsong = value; }
+
+        nlohmann::json const & get_submergement() const { return submergement; }
+        nlohmann::json & get_mutable_submergement() { return submergement; }
+        void set_submergement(nlohmann::json const & value) { this->submergement = value; }
+
+        nlohmann::json const & get_supraoesophagal() const { return supraoesophagal; }
+        nlohmann::json & get_mutable_supraoesophagal() { return supraoesophagal; }
+        void set_supraoesophagal(nlohmann::json const & value) { this->supraoesophagal = value; }
+
+        nlohmann::json const & get_thrashel() const { return thrashel; }
+        nlohmann::json & get_mutable_thrashel() { return thrashel; }
+        void set_thrashel(nlohmann::json const & value) { this->thrashel = value; }
+
+        nlohmann::json const & get_tyremesis() const { return tyremesis; }
+        nlohmann::json & get_mutable_tyremesis() { return tyremesis; }
+        void set_tyremesis(nlohmann::json const & value) { this->tyremesis = value; }
+
+        nlohmann::json const & get_yoruba() const { return yoruba; }
+        nlohmann::json & get_mutable_yoruba() { return yoruba; }
+        void set_yoruba(nlohmann::json const & value) { this->yoruba = value; }
+    };
+
+    using PotwhiskyElement = std::optional<std::variant<PotwhiskyClass, int64_t>>;
+
+    using Practicalizer = std::variant<std::vector<nlohmann::json>, MonaziteClass, std::string>;
+
+    class PrefreshmanClass {
+        public:
+        PrefreshmanClass() = default;
+        virtual ~PrefreshmanClass() = default;
+
+        private:
+        nlohmann::json azorubine;
+        nlohmann::json choroiditis;
+        nlohmann::json coagulatory;
+        nlohmann::json cyclorama;
+        nlohmann::json dolphus;
+        nlohmann::json duckhearted;
+        nlohmann::json ficus;
+        nlohmann::json gemaric;
+        nlohmann::json jugation;
+        nlohmann::json myoliposis;
+        nlohmann::json nonnomination;
+        nlohmann::json palay;
+        nlohmann::json pentactinal;
+        nlohmann::json phaet;
+        nlohmann::json piquant;
+        nlohmann::json registration;
+        nlohmann::json remancipation;
+        nlohmann::json scutatiform;
+        nlohmann::json theodolite;
+        nlohmann::json underward;
+
+        public:
+        nlohmann::json const & get_azorubine() const { return azorubine; }
+        nlohmann::json & get_mutable_azorubine() { return azorubine; }
+        void set_azorubine(nlohmann::json const & value) { this->azorubine = value; }
+
+        nlohmann::json const & get_choroiditis() const { return choroiditis; }
+        nlohmann::json & get_mutable_choroiditis() { return choroiditis; }
+        void set_choroiditis(nlohmann::json const & value) { this->choroiditis = value; }
+
+        nlohmann::json const & get_coagulatory() const { return coagulatory; }
+        nlohmann::json & get_mutable_coagulatory() { return coagulatory; }
+        void set_coagulatory(nlohmann::json const & value) { this->coagulatory = value; }
+
+        nlohmann::json const & get_cyclorama() const { return cyclorama; }
+        nlohmann::json & get_mutable_cyclorama() { return cyclorama; }
+        void set_cyclorama(nlohmann::json const & value) { this->cyclorama = value; }
+
+        nlohmann::json const & get_dolphus() const { return dolphus; }
+        nlohmann::json & get_mutable_dolphus() { return dolphus; }
+        void set_dolphus(nlohmann::json const & value) { this->dolphus = value; }
+
+        nlohmann::json const & get_duckhearted() const { return duckhearted; }
+        nlohmann::json & get_mutable_duckhearted() { return duckhearted; }
+        void set_duckhearted(nlohmann::json const & value) { this->duckhearted = value; }
+
+        nlohmann::json const & get_ficus() const { return ficus; }
+        nlohmann::json & get_mutable_ficus() { return ficus; }
+        void set_ficus(nlohmann::json const & value) { this->ficus = value; }
+
+        nlohmann::json const & get_gemaric() const { return gemaric; }
+        nlohmann::json & get_mutable_gemaric() { return gemaric; }
+        void set_gemaric(nlohmann::json const & value) { this->gemaric = value; }
+
+        nlohmann::json const & get_jugation() const { return jugation; }
+        nlohmann::json & get_mutable_jugation() { return jugation; }
+        void set_jugation(nlohmann::json const & value) { this->jugation = value; }
+
+        nlohmann::json const & get_myoliposis() const { return myoliposis; }
+        nlohmann::json & get_mutable_myoliposis() { return myoliposis; }
+        void set_myoliposis(nlohmann::json const & value) { this->myoliposis = value; }
+
+        nlohmann::json const & get_nonnomination() const { return nonnomination; }
+        nlohmann::json & get_mutable_nonnomination() { return nonnomination; }
+        void set_nonnomination(nlohmann::json const & value) { this->nonnomination = value; }
+
+        nlohmann::json const & get_palay() const { return palay; }
+        nlohmann::json & get_mutable_palay() { return palay; }
+        void set_palay(nlohmann::json const & value) { this->palay = value; }
+
+        nlohmann::json const & get_pentactinal() const { return pentactinal; }
+        nlohmann::json & get_mutable_pentactinal() { return pentactinal; }
+        void set_pentactinal(nlohmann::json const & value) { this->pentactinal = value; }
+
+        nlohmann::json const & get_phaet() const { return phaet; }
+        nlohmann::json & get_mutable_phaet() { return phaet; }
+        void set_phaet(nlohmann::json const & value) { this->phaet = value; }
+
+        nlohmann::json const & get_piquant() const { return piquant; }
+        nlohmann::json & get_mutable_piquant() { return piquant; }
+        void set_piquant(nlohmann::json const & value) { this->piquant = value; }
+
+        nlohmann::json const & get_registration() const { return registration; }
+        nlohmann::json & get_mutable_registration() { return registration; }
+        void set_registration(nlohmann::json const & value) { this->registration = value; }
+
+        nlohmann::json const & get_remancipation() const { return remancipation; }
+        nlohmann::json & get_mutable_remancipation() { return remancipation; }
+        void set_remancipation(nlohmann::json const & value) { this->remancipation = value; }
+
+        nlohmann::json const & get_scutatiform() const { return scutatiform; }
+        nlohmann::json & get_mutable_scutatiform() { return scutatiform; }
+        void set_scutatiform(nlohmann::json const & value) { this->scutatiform = value; }
+
+        nlohmann::json const & get_theodolite() const { return theodolite; }
+        nlohmann::json & get_mutable_theodolite() { return theodolite; }
+        void set_theodolite(nlohmann::json const & value) { this->theodolite = value; }
+
+        nlohmann::json const & get_underward() const { return underward; }
+        nlohmann::json & get_mutable_underward() { return underward; }
+        void set_underward(nlohmann::json const & value) { this->underward = value; }
+    };
+
+    using PrefreshmanElement = std::variant<std::vector<nlohmann::json>, PrefreshmanClass, std::string>;
+
+    using Prehensility = std::variant<std::vector<nlohmann::json>, bool, MonaziteClass>;
+
+    using Prevoidance = std::variant<std::vector<int64_t>, MonaziteClass, int64_t>;
+
+    using Protext = std::variant<std::vector<int64_t>, bool, MonaziteClass>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::vector<JurorElement> juror;
+        std::vector<Kongoni> kongoni;
+        std::vector<LadronismElement> ladronism;
+        std::vector<LandlubberlyElement> landlubberly;
+        std::vector<Listener> listener;
+        std::vector<LupusElement> lupus;
+        std::vector<Maslin> maslin;
+        std::vector<MonaziteElement> monazite;
+        std::vector<Monoliteral> monoliteral;
+        std::vector<MonotheisticallyElement> monotheistically;
+        std::vector<Montage> montage;
+        std::vector<Moralness> moralness;
+        std::vector<std::optional<MonaziteClass>> mowra;
+        std::vector<Mulishly> mulishly;
+        std::vector<Myoscope> myoscope;
+        std::vector<std::optional<std::vector<std::optional<int64_t>>>> nach;
+        std::vector<Neuromastic> neuromastic;
+        std::vector<Noncontributing> noncontributing;
+        std::vector<Nonnervous> nonnervous;
+        std::vector<Nonvaluation> nonvaluation;
+        std::vector<OccupationalistElement> occupationalist;
+        std::vector<OutrivalElement> outrival;
+        std::vector<Paleographically> paleographically;
+        std::vector<Pamphletwise> pamphletwise;
+        std::vector<Pediatric> pediatrics;
+        std::vector<bool> perceptive;
+        std::vector<PiaculumElement> piaculum;
+        std::vector<Piccadilly> piccadilly;
+        std::vector<Piffler> piffler;
+        std::vector<Pithful> pithful;
+        std::vector<Placuntiti> placuntitis;
+        std::vector<Plectopterous> plectopterous;
+        std::vector<std::optional<Pneumocele>> pneumocele;
+        std::vector<Poliorcetic> poliorcetic;
+        std::vector<Poormaster> poormaster;
+        std::vector<PotwhiskyElement> potwhisky;
+        std::vector<Practicalizer> practicalizer;
+        std::vector<PrefreshmanElement> prefreshman;
+        std::vector<Prehensility> prehensility;
+        std::vector<Prevoidance> prevoidance;
+        std::vector<std::map<std::string, std::optional<int64_t>>> probant;
+        std::vector<Protext> protext;
+
+        public:
+        std::vector<JurorElement> const & get_juror() const { return juror; }
+        std::vector<JurorElement> & get_mutable_juror() { return juror; }
+        void set_juror(std::vector<JurorElement> const & value) { this->juror = value; }
+
+        std::vector<Kongoni> const & get_kongoni() const { return kongoni; }
+        std::vector<Kongoni> & get_mutable_kongoni() { return kongoni; }
+        void set_kongoni(std::vector<Kongoni> const & value) { this->kongoni = value; }
+
+        std::vector<LadronismElement> const & get_ladronism() const { return ladronism; }
+        std::vector<LadronismElement> & get_mutable_ladronism() { return ladronism; }
+        void set_ladronism(std::vector<LadronismElement> const & value) { this->ladronism = value; }
+
+        std::vector<LandlubberlyElement> const & get_landlubberly() const { return landlubberly; }
+        std::vector<LandlubberlyElement> & get_mutable_landlubberly() { return landlubberly; }
+        void set_landlubberly(std::vector<LandlubberlyElement> const & value) { this->landlubberly = value; }
+
+        std::vector<Listener> const & get_listener() const { return listener; }
+        std::vector<Listener> & get_mutable_listener() { return listener; }
+        void set_listener(std::vector<Listener> const & value) { this->listener = value; }
+
+        std::vector<LupusElement> const & get_lupus() const { return lupus; }
+        std::vector<LupusElement> & get_mutable_lupus() { return lupus; }
+        void set_lupus(std::vector<LupusElement> const & value) { this->lupus = value; }
+
+        std::vector<Maslin> const & get_maslin() const { return maslin; }
+        std::vector<Maslin> & get_mutable_maslin() { return maslin; }
+        void set_maslin(std::vector<Maslin> const & value) { this->maslin = value; }
+
+        std::vector<MonaziteElement> const & get_monazite() const { return monazite; }
+        std::vector<MonaziteElement> & get_mutable_monazite() { return monazite; }
+        void set_monazite(std::vector<MonaziteElement> const & value) { this->monazite = value; }
+
+        std::vector<Monoliteral> const & get_monoliteral() const { return monoliteral; }
+        std::vector<Monoliteral> & get_mutable_monoliteral() { return monoliteral; }
+        void set_monoliteral(std::vector<Monoliteral> const & value) { this->monoliteral = value; }
+
+        std::vector<MonotheisticallyElement> const & get_monotheistically() const { return monotheistically; }
+        std::vector<MonotheisticallyElement> & get_mutable_monotheistically() { return monotheistically; }
+        void set_monotheistically(std::vector<MonotheisticallyElement> const & value) { this->monotheistically = value; }
+
+        std::vector<Montage> const & get_montage() const { return montage; }
+        std::vector<Montage> & get_mutable_montage() { return montage; }
+        void set_montage(std::vector<Montage> const & value) { this->montage = value; }
+
+        std::vector<Moralness> const & get_moralness() const { return moralness; }
+        std::vector<Moralness> & get_mutable_moralness() { return moralness; }
+        void set_moralness(std::vector<Moralness> const & value) { this->moralness = value; }
+
+        std::vector<std::optional<MonaziteClass>> const & get_mowra() const { return mowra; }
+        std::vector<std::optional<MonaziteClass>> & get_mutable_mowra() { return mowra; }
+        void set_mowra(std::vector<std::optional<MonaziteClass>> const & value) { this->mowra = value; }
+
+        std::vector<Mulishly> const & get_mulishly() const { return mulishly; }
+        std::vector<Mulishly> & get_mutable_mulishly() { return mulishly; }
+        void set_mulishly(std::vector<Mulishly> const & value) { this->mulishly = value; }
+
+        std::vector<Myoscope> const & get_myoscope() const { return myoscope; }
+        std::vector<Myoscope> & get_mutable_myoscope() { return myoscope; }
+        void set_myoscope(std::vector<Myoscope> const & value) { this->myoscope = value; }
+
+        std::vector<std::optional<std::vector<std::optional<int64_t>>>> const & get_nach() const { return nach; }
+        std::vector<std::optional<std::vector<std::optional<int64_t>>>> & get_mutable_nach() { return nach; }
+        void set_nach(std::vector<std::optional<std::vector<std::optional<int64_t>>>> const & value) { this->nach = value; }
+
+        std::vector<Neuromastic> const & get_neuromastic() const { return neuromastic; }
+        std::vector<Neuromastic> & get_mutable_neuromastic() { return neuromastic; }
+        void set_neuromastic(std::vector<Neuromastic> const & value) { this->neuromastic = value; }
+
+        std::vector<Noncontributing> const & get_noncontributing() const { return noncontributing; }
+        std::vector<Noncontributing> & get_mutable_noncontributing() { return noncontributing; }
+        void set_noncontributing(std::vector<Noncontributing> const & value) { this->noncontributing = value; }
+
+        std::vector<Nonnervous> const & get_nonnervous() const { return nonnervous; }
+        std::vector<Nonnervous> & get_mutable_nonnervous() { return nonnervous; }
+        void set_nonnervous(std::vector<Nonnervous> const & value) { this->nonnervous = value; }
+
+        std::vector<Nonvaluation> const & get_nonvaluation() const { return nonvaluation; }
+        std::vector<Nonvaluation> & get_mutable_nonvaluation() { return nonvaluation; }
+        void set_nonvaluation(std::vector<Nonvaluation> const & value) { this->nonvaluation = value; }
+
+        std::vector<OccupationalistElement> const & get_occupationalist() const { return occupationalist; }
+        std::vector<OccupationalistElement> & get_mutable_occupationalist() { return occupationalist; }
+        void set_occupationalist(std::vector<OccupationalistElement> const & value) { this->occupationalist = value; }
+
+        std::vector<OutrivalElement> const & get_outrival() const { return outrival; }
+        std::vector<OutrivalElement> & get_mutable_outrival() { return outrival; }
+        void set_outrival(std::vector<OutrivalElement> const & value) { this->outrival = value; }
+
+        std::vector<Paleographically> const & get_paleographically() const { return paleographically; }
+        std::vector<Paleographically> & get_mutable_paleographically() { return paleographically; }
+        void set_paleographically(std::vector<Paleographically> const & value) { this->paleographically = value; }
+
+        std::vector<Pamphletwise> const & get_pamphletwise() const { return pamphletwise; }
+        std::vector<Pamphletwise> & get_mutable_pamphletwise() { return pamphletwise; }
+        void set_pamphletwise(std::vector<Pamphletwise> const & value) { this->pamphletwise = value; }
+
+        std::vector<Pediatric> const & get_pediatrics() const { return pediatrics; }
+        std::vector<Pediatric> & get_mutable_pediatrics() { return pediatrics; }
+        void set_pediatrics(std::vector<Pediatric> const & value) { this->pediatrics = value; }
+
+        std::vector<bool> const & get_perceptive() const { return perceptive; }
+        std::vector<bool> & get_mutable_perceptive() { return perceptive; }
+        void set_perceptive(std::vector<bool> const & value) { this->perceptive = value; }
+
+        std::vector<PiaculumElement> const & get_piaculum() const { return piaculum; }
+        std::vector<PiaculumElement> & get_mutable_piaculum() { return piaculum; }
+        void set_piaculum(std::vector<PiaculumElement> const & value) { this->piaculum = value; }
+
+        std::vector<Piccadilly> const & get_piccadilly() const { return piccadilly; }
+        std::vector<Piccadilly> & get_mutable_piccadilly() { return piccadilly; }
+        void set_piccadilly(std::vector<Piccadilly> const & value) { this->piccadilly = value; }
+
+        std::vector<Piffler> const & get_piffler() const { return piffler; }
+        std::vector<Piffler> & get_mutable_piffler() { return piffler; }
+        void set_piffler(std::vector<Piffler> const & value) { this->piffler = value; }
+
+        std::vector<Pithful> const & get_pithful() const { return pithful; }
+        std::vector<Pithful> & get_mutable_pithful() { return pithful; }
+        void set_pithful(std::vector<Pithful> const & value) { this->pithful = value; }
+
+        std::vector<Placuntiti> const & get_placuntitis() const { return placuntitis; }
+        std::vector<Placuntiti> & get_mutable_placuntitis() { return placuntitis; }
+        void set_placuntitis(std::vector<Placuntiti> const & value) { this->placuntitis = value; }
+
+        std::vector<Plectopterous> const & get_plectopterous() const { return plectopterous; }
+        std::vector<Plectopterous> & get_mutable_plectopterous() { return plectopterous; }
+        void set_plectopterous(std::vector<Plectopterous> const & value) { this->plectopterous = value; }
+
+        std::vector<std::optional<Pneumocele>> const & get_pneumocele() const { return pneumocele; }
+        std::vector<std::optional<Pneumocele>> & get_mutable_pneumocele() { return pneumocele; }
+        void set_pneumocele(std::vector<std::optional<Pneumocele>> const & value) { this->pneumocele = value; }
+
+        std::vector<Poliorcetic> const & get_poliorcetic() const { return poliorcetic; }
+        std::vector<Poliorcetic> & get_mutable_poliorcetic() { return poliorcetic; }
+        void set_poliorcetic(std::vector<Poliorcetic> const & value) { this->poliorcetic = value; }
+
+        std::vector<Poormaster> const & get_poormaster() const { return poormaster; }
+        std::vector<Poormaster> & get_mutable_poormaster() { return poormaster; }
+        void set_poormaster(std::vector<Poormaster> const & value) { this->poormaster = value; }
+
+        std::vector<PotwhiskyElement> const & get_potwhisky() const { return potwhisky; }
+        std::vector<PotwhiskyElement> & get_mutable_potwhisky() { return potwhisky; }
+        void set_potwhisky(std::vector<PotwhiskyElement> const & value) { this->potwhisky = value; }
+
+        std::vector<Practicalizer> const & get_practicalizer() const { return practicalizer; }
+        std::vector<Practicalizer> & get_mutable_practicalizer() { return practicalizer; }
+        void set_practicalizer(std::vector<Practicalizer> const & value) { this->practicalizer = value; }
+
+        std::vector<PrefreshmanElement> const & get_prefreshman() const { return prefreshman; }
+        std::vector<PrefreshmanElement> & get_mutable_prefreshman() { return prefreshman; }
+        void set_prefreshman(std::vector<PrefreshmanElement> const & value) { this->prefreshman = value; }
+
+        std::vector<Prehensility> const & get_prehensility() const { return prehensility; }
+        std::vector<Prehensility> & get_mutable_prehensility() { return prehensility; }
+        void set_prehensility(std::vector<Prehensility> const & value) { this->prehensility = value; }
+
+        std::vector<Prevoidance> const & get_prevoidance() const { return prevoidance; }
+        std::vector<Prevoidance> & get_mutable_prevoidance() { return prevoidance; }
+        void set_prevoidance(std::vector<Prevoidance> const & value) { this->prevoidance = value; }
+
+        std::vector<std::map<std::string, std::optional<int64_t>>> const & get_probant() const { return probant; }
+        std::vector<std::map<std::string, std::optional<int64_t>>> & get_mutable_probant() { return probant; }
+        void set_probant(std::vector<std::map<std::string, std::optional<int64_t>>> const & value) { this->probant = value; }
+
+        std::vector<Protext> const & get_protext() const { return protext; }
+        std::vector<Protext> & get_mutable_protext() { return protext; }
+        void set_protext(std::vector<Protext> const & value) { this->protext = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(json const & j, JurorClass & x);
+void to_json(json & j, JurorClass const & x);
+
+void from_json(json const & j, LadronismClass & x);
+void to_json(json & j, LadronismClass const & x);
+
+void from_json(json const & j, LandlubberlyClass & x);
+void to_json(json & j, LandlubberlyClass const & x);
+
+void from_json(json const & j, LupusClass & x);
+void to_json(json & j, LupusClass const & x);
+
+void from_json(json const & j, Maslin & x);
+void to_json(json & j, Maslin const & x);
+
+void from_json(json const & j, MonaziteClass & x);
+void to_json(json & j, MonaziteClass const & x);
+
+void from_json(json const & j, MonotheisticallyClass & x);
+void to_json(json & j, MonotheisticallyClass const & x);
+
+void from_json(json const & j, Noncontributing & x);
+void to_json(json & j, Noncontributing const & x);
+
+void from_json(json const & j, OccupationalistClass & x);
+void to_json(json & j, OccupationalistClass const & x);
+
+void from_json(json const & j, OutrivalClass & x);
+void to_json(json & j, OutrivalClass const & x);
+
+void from_json(json const & j, PiaculumClass & x);
+void to_json(json & j, PiaculumClass const & x);
+
+void from_json(json const & j, Pneumocele & x);
+void to_json(json & j, Pneumocele const & x);
+
+void from_json(json const & j, PotwhiskyClass & x);
+void to_json(json & j, PotwhiskyClass const & x);
+
+void from_json(json const & j, PrefreshmanClass & x);
+void to_json(json & j, PrefreshmanClass const & x);
+
+void from_json(json const & j, TopLevel & x);
+void to_json(json & j, TopLevel const & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<bool, quicktype::JurorClass>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::JurorClass> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::JurorClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::LadronismClass, double, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::LadronismClass, double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LupusClass, int64_t>> {
+    static void from_json(json const & j, std::variant<quicktype::LupusClass, int64_t> & x);
+    static void to_json(json & j, std::variant<quicktype::LupusClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::MonaziteClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::MonaziteClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::MonaziteClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, double, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, double> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t>> {
+    static void from_json(json const & j, std::variant<bool, int64_t> & x);
+    static void to_json(json & j, std::variant<bool, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, double>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool, double> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::OutrivalClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::OutrivalClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::OutrivalClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(json const & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(json const & j, std::variant<bool, double> & x);
+    static void to_json(json & j, std::variant<bool, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PiaculumClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::PiaculumClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::PiaculumClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(json const & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, std::variant<double, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::MonaziteClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<int64_t, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<double, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::MonaziteClass>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::MonaziteClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>> {
+    static void from_json(json const & j, std::variant<quicktype::PotwhiskyClass, int64_t> & x);
+    static void to_json(json & j, std::variant<quicktype::PotwhiskyClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> const & x);
+};
+}
+namespace quicktype {
+    inline void from_json(json const & j, JurorClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_adipsy(get_untyped(j, "adipsy"));
+        x.set_auxiliator(get_untyped(j, "auxiliator"));
+        x.set_benda(get_untyped(j, "benda"));
+        x.set_benjamin(get_untyped(j, "benjamin"));
+        x.set_brandling(get_untyped(j, "brandling"));
+        x.set_epicurishly(get_untyped(j, "epicurishly"));
+        x.set_eremochaetous(get_untyped(j, "eremochaetous"));
+        x.set_marten(get_untyped(j, "marten"));
+        x.set_monocline(get_untyped(j, "monocline"));
+        x.set_olea(get_untyped(j, "Olea"));
+        x.set_palgat(get_untyped(j, "palgat"));
+        x.set_pennyworth(get_untyped(j, "pennyworth"));
+        x.set_pioury(get_untyped(j, "pioury"));
+        x.set_pragmatistic(get_untyped(j, "pragmatistic"));
+        x.set_stylelessness(get_untyped(j, "stylelessness"));
+        x.set_systematical(get_untyped(j, "systematical"));
+        x.set_thready(get_untyped(j, "thready"));
+        x.set_uncontemporary(get_untyped(j, "uncontemporary"));
+        x.set_uncouched(get_untyped(j, "uncouched"));
+        x.set_uninhabitedness(get_untyped(j, "uninhabitedness"));
+    }
+
+    inline void to_json(json & j, JurorClass const & x) {
+        j = json::object();
+        j["adipsy"] = x.get_adipsy();
+        j["auxiliator"] = x.get_auxiliator();
+        j["benda"] = x.get_benda();
+        j["benjamin"] = x.get_benjamin();
+        j["brandling"] = x.get_brandling();
+        j["epicurishly"] = x.get_epicurishly();
+        j["eremochaetous"] = x.get_eremochaetous();
+        j["marten"] = x.get_marten();
+        j["monocline"] = x.get_monocline();
+        j["Olea"] = x.get_olea();
+        j["palgat"] = x.get_palgat();
+        j["pennyworth"] = x.get_pennyworth();
+        j["pioury"] = x.get_pioury();
+        j["pragmatistic"] = x.get_pragmatistic();
+        j["stylelessness"] = x.get_stylelessness();
+        j["systematical"] = x.get_systematical();
+        j["thready"] = x.get_thready();
+        j["uncontemporary"] = x.get_uncontemporary();
+        j["uncouched"] = x.get_uncouched();
+        j["uninhabitedness"] = x.get_uninhabitedness();
+    }
+
+    inline void from_json(json const & j, LadronismClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acclaimer(get_untyped(j, "acclaimer"));
+        x.set_achree(get_untyped(j, "achree"));
+        x.set_base(get_untyped(j, "base"));
+        x.set_conundrumize(get_untyped(j, "conundrumize"));
+        x.set_degerminator(get_untyped(j, "degerminator"));
+        x.set_describable(get_untyped(j, "describable"));
+        x.set_exasperatedly(get_untyped(j, "exasperatedly"));
+        x.set_heroine(get_untyped(j, "heroine"));
+        x.set_indazin(get_untyped(j, "indazin"));
+        x.set_luteous(get_untyped(j, "luteous"));
+        x.set_papular(get_untyped(j, "papular"));
+        x.set_pritch(get_untyped(j, "pritch"));
+        x.set_prodenia(get_untyped(j, "Prodenia"));
+        x.set_seege(get_untyped(j, "seege"));
+        x.set_shopgirl(get_untyped(j, "shopgirl"));
+        x.set_tragedietta(get_untyped(j, "tragedietta"));
+        x.set_unsparse(get_untyped(j, "unsparse"));
+        x.set_uplook(get_untyped(j, "uplook"));
+        x.set_vermiformis(get_untyped(j, "vermiformis"));
+        x.set_whafabout(get_untyped(j, "whafabout"));
+    }
+
+    inline void to_json(json & j, LadronismClass const & x) {
+        j = json::object();
+        j["acclaimer"] = x.get_acclaimer();
+        j["achree"] = x.get_achree();
+        j["base"] = x.get_base();
+        j["conundrumize"] = x.get_conundrumize();
+        j["degerminator"] = x.get_degerminator();
+        j["describable"] = x.get_describable();
+        j["exasperatedly"] = x.get_exasperatedly();
+        j["heroine"] = x.get_heroine();
+        j["indazin"] = x.get_indazin();
+        j["luteous"] = x.get_luteous();
+        j["papular"] = x.get_papular();
+        j["pritch"] = x.get_pritch();
+        j["Prodenia"] = x.get_prodenia();
+        j["seege"] = x.get_seege();
+        j["shopgirl"] = x.get_shopgirl();
+        j["tragedietta"] = x.get_tragedietta();
+        j["unsparse"] = x.get_unsparse();
+        j["uplook"] = x.get_uplook();
+        j["vermiformis"] = x.get_vermiformis();
+        j["whafabout"] = x.get_whafabout();
+    }
+
+    inline void from_json(json const & j, LandlubberlyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acropoleis(get_untyped(j, "acropoleis"));
+        x.set_aminate(get_untyped(j, "aminate"));
+        x.set_amyraldism(get_untyped(j, "Amyraldism"));
+        x.set_bipenniform(get_untyped(j, "bipenniform"));
+        x.set_bugre(get_untyped(j, "bugre"));
+        x.set_calycule(get_untyped(j, "calycule"));
+        x.set_caoutchouc(get_untyped(j, "caoutchouc"));
+        x.set_disprover(get_untyped(j, "disprover"));
+        x.set_fitroot(get_untyped(j, "fitroot"));
+        x.set_fulgently(get_untyped(j, "fulgently"));
+        x.set_kickup(get_untyped(j, "kickup"));
+        x.set_laevoversion(get_untyped(j, "laevoversion"));
+        x.set_moter(get_untyped(j, "moter"));
+        x.set_objectivity(get_untyped(j, "objectivity"));
+        x.set_posterity(get_untyped(j, "posterity"));
+        x.set_postnuptial(get_untyped(j, "postnuptial"));
+        x.set_precedentary(get_untyped(j, "precedentary"));
+        x.set_saddling(get_untyped(j, "saddling"));
+        x.set_subcurrent(get_untyped(j, "subcurrent"));
+        x.set_unrecriminative(get_untyped(j, "unrecriminative"));
+    }
+
+    inline void to_json(json & j, LandlubberlyClass const & x) {
+        j = json::object();
+        j["acropoleis"] = x.get_acropoleis();
+        j["aminate"] = x.get_aminate();
+        j["Amyraldism"] = x.get_amyraldism();
+        j["bipenniform"] = x.get_bipenniform();
+        j["bugre"] = x.get_bugre();
+        j["calycule"] = x.get_calycule();
+        j["caoutchouc"] = x.get_caoutchouc();
+        j["disprover"] = x.get_disprover();
+        j["fitroot"] = x.get_fitroot();
+        j["fulgently"] = x.get_fulgently();
+        j["kickup"] = x.get_kickup();
+        j["laevoversion"] = x.get_laevoversion();
+        j["moter"] = x.get_moter();
+        j["objectivity"] = x.get_objectivity();
+        j["posterity"] = x.get_posterity();
+        j["postnuptial"] = x.get_postnuptial();
+        j["precedentary"] = x.get_precedentary();
+        j["saddling"] = x.get_saddling();
+        j["subcurrent"] = x.get_subcurrent();
+        j["unrecriminative"] = x.get_unrecriminative();
+    }
+
+    inline void from_json(json const & j, LupusClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chlorioninae(get_stack_optional<int64_t>(j, "Chlorioninae"));
+        x.set_corvinae(get_stack_optional<int64_t>(j, "Corvinae"));
+        x.set_crassina(get_stack_optional<int64_t>(j, "Crassina"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_exiguity(get_stack_optional<int64_t>(j, "exiguity"));
+        x.set_farcist(get_stack_optional<int64_t>(j, "farcist"));
+        x.set_holographical(get_stack_optional<int64_t>(j, "holographical"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_ichthyophagan(get_stack_optional<int64_t>(j, "ichthyophagan"));
+        x.set_implacable(get_stack_optional<int64_t>(j, "implacable"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_outshiner(get_stack_optional<int64_t>(j, "outshiner"));
+        x.set_overweather(get_stack_optional<int64_t>(j, "overweather"));
+        x.set_protonegroid(get_stack_optional<int64_t>(j, "protonegroid"));
+        x.set_shallowish(get_stack_optional<int64_t>(j, "shallowish"));
+        x.set_snoke(get_stack_optional<int64_t>(j, "snoke"));
+        x.set_snout(get_stack_optional<int64_t>(j, "snout"));
+        x.set_surveillance(get_stack_optional<int64_t>(j, "surveillance"));
+        x.set_threshingtime(get_stack_optional<int64_t>(j, "threshingtime"));
+        x.set_thysanocarpus(get_stack_optional<int64_t>(j, "Thysanocarpus"));
+        x.set_unsignificantly(get_stack_optional<int64_t>(j, "unsignificantly"));
+        x.set_unsnap(get_stack_optional<int64_t>(j, "unsnap"));
+        x.set_vendible(get_stack_optional<int64_t>(j, "vendible"));
+    }
+
+    inline void to_json(json & j, LupusClass const & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["Chlorioninae"] = x.get_chlorioninae();
+        j["Corvinae"] = x.get_corvinae();
+        j["Crassina"] = x.get_crassina();
+        j["disdiapason"] = x.get_disdiapason();
+        j["exiguity"] = x.get_exiguity();
+        j["farcist"] = x.get_farcist();
+        j["holographical"] = x.get_holographical();
+        j["homocerc"] = x.get_homocerc();
+        j["ichthyophagan"] = x.get_ichthyophagan();
+        j["implacable"] = x.get_implacable();
+        j["nonbookish"] = x.get_nonbookish();
+        j["outshiner"] = x.get_outshiner();
+        j["overweather"] = x.get_overweather();
+        j["protonegroid"] = x.get_protonegroid();
+        j["shallowish"] = x.get_shallowish();
+        j["snoke"] = x.get_snoke();
+        j["snout"] = x.get_snout();
+        j["surveillance"] = x.get_surveillance();
+        j["threshingtime"] = x.get_threshingtime();
+        j["Thysanocarpus"] = x.get_thysanocarpus();
+        j["unsignificantly"] = x.get_unsignificantly();
+        j["unsnap"] = x.get_unsnap();
+        j["vendible"] = x.get_vendible();
+    }
+
+    inline void from_json(json const & j, Maslin& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alicant(get_stack_optional<int64_t>(j, "Alicant"));
+        x.set_antiatonement(get_untyped(j, "antiatonement"));
+        x.set_anticorrosive(get_stack_optional<int64_t>(j, "anticorrosive"));
+        x.set_aphidozer(get_untyped(j, "aphidozer"));
+        x.set_bakuninist(get_untyped(j, "Bakuninist"));
+        x.set_be(get_stack_optional<int64_t>(j, "be"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chub(get_stack_optional<int64_t>(j, "chub"));
+        x.set_cuprosilicon(get_stack_optional<int64_t>(j, "cuprosilicon"));
+        x.set_curtailedly(get_stack_optional<int64_t>(j, "curtailedly"));
+        x.set_dellenite(get_stack_optional<int64_t>(j, "dellenite"));
+        x.set_dimitry(get_stack_optional<int64_t>(j, "Dimitry"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_edifying(get_untyped(j, "edifying"));
+        x.set_ethmoiditis(get_stack_optional<int64_t>(j, "ethmoiditis"));
+        x.set_gastralgy(get_untyped(j, "gastralgy"));
+        x.set_goatherd(get_stack_optional<int64_t>(j, "goatherd"));
+        x.set_hammerdress(get_stack_optional<int64_t>(j, "hammerdress"));
+        x.set_hangfire(get_untyped(j, "hangfire"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_lacunosity(get_stack_optional<int64_t>(j, "lacunosity"));
+        x.set_longiloquence(get_untyped(j, "longiloquence"));
+        x.set_mameliere(get_stack_optional<int64_t>(j, "mameliere"));
+        x.set_motherless(get_untyped(j, "motherless"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_noncorrodible(get_untyped(j, "noncorrodible"));
+        x.set_nonsensicality(get_untyped(j, "nonsensicality"));
+        x.set_oafishly(get_stack_optional<int64_t>(j, "oafishly"));
+        x.set_pfund(get_untyped(j, "pfund"));
+        x.set_preadvisory(get_untyped(j, "preadvisory"));
+        x.set_retroflexed(get_untyped(j, "retroflexed"));
+        x.set_saccharulmic(get_stack_optional<int64_t>(j, "saccharulmic"));
+        x.set_scowlful(get_stack_optional<int64_t>(j, "scowlful"));
+        x.set_secluded(get_untyped(j, "secluded"));
+        x.set_slackage(get_untyped(j, "slackage"));
+        x.set_sphaeridial(get_stack_optional<int64_t>(j, "sphaeridial"));
+        x.set_spondulics(get_untyped(j, "spondulics"));
+        x.set_subsecive(get_stack_optional<int64_t>(j, "subsecive"));
+        x.set_swellmobsman(get_untyped(j, "swellmobsman"));
+        x.set_trachyglossate(get_stack_optional<int64_t>(j, "trachyglossate"));
+        x.set_trialogue(get_untyped(j, "trialogue"));
+        x.set_unassuaged(get_stack_optional<int64_t>(j, "unassuaged"));
+        x.set_ungross(get_untyped(j, "ungross"));
+        x.set_unjudiciously(get_untyped(j, "unjudiciously"));
+    }
+
+    inline void to_json(json & j, Maslin const & x) {
+        j = json::object();
+        j["Alicant"] = x.get_alicant();
+        j["antiatonement"] = x.get_antiatonement();
+        j["anticorrosive"] = x.get_anticorrosive();
+        j["aphidozer"] = x.get_aphidozer();
+        j["Bakuninist"] = x.get_bakuninist();
+        j["be"] = x.get_be();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chub"] = x.get_chub();
+        j["cuprosilicon"] = x.get_cuprosilicon();
+        j["curtailedly"] = x.get_curtailedly();
+        j["dellenite"] = x.get_dellenite();
+        j["Dimitry"] = x.get_dimitry();
+        j["disdiapason"] = x.get_disdiapason();
+        j["edifying"] = x.get_edifying();
+        j["ethmoiditis"] = x.get_ethmoiditis();
+        j["gastralgy"] = x.get_gastralgy();
+        j["goatherd"] = x.get_goatherd();
+        j["hammerdress"] = x.get_hammerdress();
+        j["hangfire"] = x.get_hangfire();
+        j["homocerc"] = x.get_homocerc();
+        j["lacunosity"] = x.get_lacunosity();
+        j["longiloquence"] = x.get_longiloquence();
+        j["mameliere"] = x.get_mameliere();
+        j["motherless"] = x.get_motherless();
+        j["nonbookish"] = x.get_nonbookish();
+        j["noncorrodible"] = x.get_noncorrodible();
+        j["nonsensicality"] = x.get_nonsensicality();
+        j["oafishly"] = x.get_oafishly();
+        j["pfund"] = x.get_pfund();
+        j["preadvisory"] = x.get_preadvisory();
+        j["retroflexed"] = x.get_retroflexed();
+        j["saccharulmic"] = x.get_saccharulmic();
+        j["scowlful"] = x.get_scowlful();
+        j["secluded"] = x.get_secluded();
+        j["slackage"] = x.get_slackage();
+        j["sphaeridial"] = x.get_sphaeridial();
+        j["spondulics"] = x.get_spondulics();
+        j["subsecive"] = x.get_subsecive();
+        j["swellmobsman"] = x.get_swellmobsman();
+        j["trachyglossate"] = x.get_trachyglossate();
+        j["trialogue"] = x.get_trialogue();
+        j["unassuaged"] = x.get_unassuaged();
+        j["ungross"] = x.get_ungross();
+        j["unjudiciously"] = x.get_unjudiciously();
+    }
+
+    inline void from_json(json const & j, MonaziteClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, MonaziteClass const & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(json const & j, MonotheisticallyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_blaspheme(get_untyped(j, "blaspheme"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_celiosalpingectomy(get_untyped(j, "celiosalpingectomy"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_consummativeness(get_untyped(j, "consummativeness"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_egestive(get_untyped(j, "egestive"));
+        x.set_enchylema(get_untyped(j, "enchylema"));
+        x.set_gasconade(get_untyped(j, "gasconade"));
+        x.set_holidayer(get_untyped(j, "holidayer"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_intuitionalism(get_untyped(j, "intuitionalism"));
+        x.set_lophiostomate(get_untyped(j, "lophiostomate"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_nonvolition(get_untyped(j, "nonvolition"));
+        x.set_palatableness(get_untyped(j, "palatableness"));
+        x.set_pimpery(get_untyped(j, "pimpery"));
+        x.set_previolation(get_untyped(j, "previolation"));
+        x.set_reconveyance(get_untyped(j, "reconveyance"));
+        x.set_registership(get_untyped(j, "registership"));
+        x.set_rhyacolite(get_untyped(j, "rhyacolite"));
+        x.set_smithereens(get_untyped(j, "smithereens"));
+        x.set_superedification(get_untyped(j, "superedification"));
+        x.set_trust(get_untyped(j, "trust"));
+        x.set_whitestone(get_untyped(j, "whitestone"));
+    }
+
+    inline void to_json(json & j, MonotheisticallyClass const & x) {
+        j = json::object();
+        j["blaspheme"] = x.get_blaspheme();
+        j["catharticalness"] = x.get_catharticalness();
+        j["celiosalpingectomy"] = x.get_celiosalpingectomy();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["consummativeness"] = x.get_consummativeness();
+        j["disdiapason"] = x.get_disdiapason();
+        j["egestive"] = x.get_egestive();
+        j["enchylema"] = x.get_enchylema();
+        j["gasconade"] = x.get_gasconade();
+        j["holidayer"] = x.get_holidayer();
+        j["homocerc"] = x.get_homocerc();
+        j["intuitionalism"] = x.get_intuitionalism();
+        j["lophiostomate"] = x.get_lophiostomate();
+        j["nonbookish"] = x.get_nonbookish();
+        j["nonvolition"] = x.get_nonvolition();
+        j["palatableness"] = x.get_palatableness();
+        j["pimpery"] = x.get_pimpery();
+        j["previolation"] = x.get_previolation();
+        j["reconveyance"] = x.get_reconveyance();
+        j["registership"] = x.get_registership();
+        j["rhyacolite"] = x.get_rhyacolite();
+        j["smithereens"] = x.get_smithereens();
+        j["superedification"] = x.get_superedification();
+        j["trust"] = x.get_trust();
+        j["whitestone"] = x.get_whitestone();
+    }
+
+    inline void from_json(json const & j, Noncontributing& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_estevin(j.at("estevin").get<std::string>());
+        x.set_jolterhead(j.at("jolterhead").get<double>());
+        x.set_sauternes(j.at("sauternes").get<int64_t>());
+        x.set_sparsely(j.at("sparsely").get<bool>());
+        x.set_unrequested(get_untyped(j, "unrequested"));
+    }
+
+    inline void to_json(json & j, Noncontributing const & x) {
+        j = json::object();
+        j["estevin"] = x.get_estevin();
+        j["jolterhead"] = x.get_jolterhead();
+        j["sauternes"] = x.get_sauternes();
+        j["sparsely"] = x.get_sparsely();
+        j["unrequested"] = x.get_unrequested();
+    }
+
+    inline void from_json(json const & j, OccupationalistClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_beholdable(get_untyped(j, "beholdable"));
+        x.set_brotuliform(get_untyped(j, "brotuliform"));
+        x.set_chimakum(get_untyped(j, "Chimakum"));
+        x.set_doodler(get_untyped(j, "doodler"));
+        x.set_emulsin(get_untyped(j, "emulsin"));
+        x.set_fin(get_untyped(j, "Fin"));
+        x.set_flourishing(get_untyped(j, "flourishing"));
+        x.set_flueless(get_untyped(j, "flueless"));
+        x.set_furtively(get_untyped(j, "furtively"));
+        x.set_gritter(get_untyped(j, "gritter"));
+        x.set_interwish(get_untyped(j, "interwish"));
+        x.set_monoxylic(get_untyped(j, "monoxylic"));
+        x.set_myristic(get_untyped(j, "myristic"));
+        x.set_nightwear(get_untyped(j, "nightwear"));
+        x.set_peruser(get_untyped(j, "peruser"));
+        x.set_theoastrological(get_untyped(j, "theoastrological"));
+        x.set_thumby(get_untyped(j, "thumby"));
+        x.set_tingitid(get_untyped(j, "tingitid"));
+        x.set_trailless(get_untyped(j, "trailless"));
+        x.set_unpocketed(get_untyped(j, "unpocketed"));
+    }
+
+    inline void to_json(json & j, OccupationalistClass const & x) {
+        j = json::object();
+        j["beholdable"] = x.get_beholdable();
+        j["brotuliform"] = x.get_brotuliform();
+        j["Chimakum"] = x.get_chimakum();
+        j["doodler"] = x.get_doodler();
+        j["emulsin"] = x.get_emulsin();
+        j["Fin"] = x.get_fin();
+        j["flourishing"] = x.get_flourishing();
+        j["flueless"] = x.get_flueless();
+        j["furtively"] = x.get_furtively();
+        j["gritter"] = x.get_gritter();
+        j["interwish"] = x.get_interwish();
+        j["monoxylic"] = x.get_monoxylic();
+        j["myristic"] = x.get_myristic();
+        j["nightwear"] = x.get_nightwear();
+        j["peruser"] = x.get_peruser();
+        j["theoastrological"] = x.get_theoastrological();
+        j["thumby"] = x.get_thumby();
+        j["tingitid"] = x.get_tingitid();
+        j["trailless"] = x.get_trailless();
+        j["unpocketed"] = x.get_unpocketed();
+    }
+
+    inline void from_json(json const & j, OutrivalClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_adroitly(get_untyped(j, "adroitly"));
+        x.set_bridehood(get_untyped(j, "bridehood"));
+        x.set_castoroides(get_untyped(j, "Castoroides"));
+        x.set_czechoslovak(get_untyped(j, "Czechoslovak"));
+        x.set_diagenesis(get_untyped(j, "diagenesis"));
+        x.set_dihexahedron(get_untyped(j, "dihexahedron"));
+        x.set_dopester(get_untyped(j, "dopester"));
+        x.set_eumerism(get_untyped(j, "eumerism"));
+        x.set_flyness(get_untyped(j, "flyness"));
+        x.set_fouler(get_untyped(j, "fouler"));
+        x.set_laudanosine(get_untyped(j, "laudanosine"));
+        x.set_lingulidae(get_untyped(j, "Lingulidae"));
+        x.set_minutary(get_untyped(j, "minutary"));
+        x.set_mitra(get_untyped(j, "mitra"));
+        x.set_opisthorchiasis(get_untyped(j, "opisthorchiasis"));
+        x.set_pensively(get_untyped(j, "pensively"));
+        x.set_pubigerous(get_untyped(j, "pubigerous"));
+        x.set_rebellious(get_untyped(j, "rebellious"));
+        x.set_recodify(get_untyped(j, "recodify"));
+        x.set_unpaced(get_untyped(j, "unpaced"));
+    }
+
+    inline void to_json(json & j, OutrivalClass const & x) {
+        j = json::object();
+        j["adroitly"] = x.get_adroitly();
+        j["bridehood"] = x.get_bridehood();
+        j["Castoroides"] = x.get_castoroides();
+        j["Czechoslovak"] = x.get_czechoslovak();
+        j["diagenesis"] = x.get_diagenesis();
+        j["dihexahedron"] = x.get_dihexahedron();
+        j["dopester"] = x.get_dopester();
+        j["eumerism"] = x.get_eumerism();
+        j["flyness"] = x.get_flyness();
+        j["fouler"] = x.get_fouler();
+        j["laudanosine"] = x.get_laudanosine();
+        j["Lingulidae"] = x.get_lingulidae();
+        j["minutary"] = x.get_minutary();
+        j["mitra"] = x.get_mitra();
+        j["opisthorchiasis"] = x.get_opisthorchiasis();
+        j["pensively"] = x.get_pensively();
+        j["pubigerous"] = x.get_pubigerous();
+        j["rebellious"] = x.get_rebellious();
+        j["recodify"] = x.get_recodify();
+        j["unpaced"] = x.get_unpaced();
+    }
+
+    inline void from_json(json const & j, PiaculumClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alada(get_stack_optional<int64_t>(j, "alada"));
+        x.set_amphistomous(get_stack_optional<int64_t>(j, "amphistomous"));
+        x.set_boysenberry(get_stack_optional<int64_t>(j, "boysenberry"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_decardinalize(get_stack_optional<int64_t>(j, "decardinalize"));
+        x.set_discouragement(get_stack_optional<int64_t>(j, "discouragement"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_doitrified(get_stack_optional<int64_t>(j, "doitrified"));
+        x.set_hexaspermous(get_stack_optional<int64_t>(j, "hexaspermous"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_insinking(get_stack_optional<int64_t>(j, "insinking"));
+        x.set_loathfulness(get_stack_optional<int64_t>(j, "loathfulness"));
+        x.set_miasmatical(get_stack_optional<int64_t>(j, "miasmatical"));
+        x.set_neurofibril(get_stack_optional<int64_t>(j, "neurofibril"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_phonendoscope(get_stack_optional<int64_t>(j, "phonendoscope"));
+        x.set_pilferment(get_stack_optional<int64_t>(j, "pilferment"));
+        x.set_predismissory(get_stack_optional<int64_t>(j, "predismissory"));
+        x.set_preinscription(get_stack_optional<int64_t>(j, "preinscription"));
+        x.set_quotative(get_stack_optional<int64_t>(j, "quotative"));
+        x.set_sienna(get_stack_optional<int64_t>(j, "sienna"));
+        x.set_thorax(get_stack_optional<int64_t>(j, "thorax"));
+        x.set_yachting(get_stack_optional<int64_t>(j, "yachting"));
+        x.set_zipper(get_stack_optional<int64_t>(j, "Zipper"));
+    }
+
+    inline void to_json(json & j, PiaculumClass const & x) {
+        j = json::object();
+        j["alada"] = x.get_alada();
+        j["amphistomous"] = x.get_amphistomous();
+        j["boysenberry"] = x.get_boysenberry();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["decardinalize"] = x.get_decardinalize();
+        j["discouragement"] = x.get_discouragement();
+        j["disdiapason"] = x.get_disdiapason();
+        j["doitrified"] = x.get_doitrified();
+        j["hexaspermous"] = x.get_hexaspermous();
+        j["homocerc"] = x.get_homocerc();
+        j["insinking"] = x.get_insinking();
+        j["loathfulness"] = x.get_loathfulness();
+        j["miasmatical"] = x.get_miasmatical();
+        j["neurofibril"] = x.get_neurofibril();
+        j["nonbookish"] = x.get_nonbookish();
+        j["phonendoscope"] = x.get_phonendoscope();
+        j["pilferment"] = x.get_pilferment();
+        j["predismissory"] = x.get_predismissory();
+        j["preinscription"] = x.get_preinscription();
+        j["quotative"] = x.get_quotative();
+        j["sienna"] = x.get_sienna();
+        j["thorax"] = x.get_thorax();
+        j["yachting"] = x.get_yachting();
+        j["Zipper"] = x.get_zipper();
+    }
+
+    inline void from_json(json const & j, Pneumocele& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_carbonarism(get_untyped(j, "Carbonarism"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_cineolic(get_untyped(j, "cineolic"));
+        x.set_cobbly(get_untyped(j, "cobbly"));
+        x.set_conchyliferous(get_untyped(j, "conchyliferous"));
+        x.set_congregation(get_untyped(j, "congregation"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_enterotomy(get_untyped(j, "enterotomy"));
+        x.set_entophytal(get_untyped(j, "entophytal"));
+        x.set_fewtrils(get_untyped(j, "fewtrils"));
+        x.set_herem(get_untyped(j, "herem"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_koniga(get_untyped(j, "Koniga"));
+        x.set_meticulosity(get_untyped(j, "meticulosity"));
+        x.set_micky(get_untyped(j, "Micky"));
+        x.set_mismarriage(get_untyped(j, "mismarriage"));
+        x.set_neurotrophic(get_untyped(j, "neurotrophic"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_persuasively(get_untyped(j, "persuasively"));
+        x.set_replaceable(get_untyped(j, "replaceable"));
+        x.set_silex(get_untyped(j, "silex"));
+        x.set_taillight(get_untyped(j, "taillight"));
+        x.set_unjealous(get_untyped(j, "unjealous"));
+        x.set_visitorial(get_untyped(j, "visitorial"));
+    }
+
+    inline void to_json(json & j, Pneumocele const & x) {
+        j = json::object();
+        j["Carbonarism"] = x.get_carbonarism();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["cineolic"] = x.get_cineolic();
+        j["cobbly"] = x.get_cobbly();
+        j["conchyliferous"] = x.get_conchyliferous();
+        j["congregation"] = x.get_congregation();
+        j["disdiapason"] = x.get_disdiapason();
+        j["enterotomy"] = x.get_enterotomy();
+        j["entophytal"] = x.get_entophytal();
+        j["fewtrils"] = x.get_fewtrils();
+        j["herem"] = x.get_herem();
+        j["homocerc"] = x.get_homocerc();
+        j["Koniga"] = x.get_koniga();
+        j["meticulosity"] = x.get_meticulosity();
+        j["Micky"] = x.get_micky();
+        j["mismarriage"] = x.get_mismarriage();
+        j["neurotrophic"] = x.get_neurotrophic();
+        j["nonbookish"] = x.get_nonbookish();
+        j["persuasively"] = x.get_persuasively();
+        j["replaceable"] = x.get_replaceable();
+        j["silex"] = x.get_silex();
+        j["taillight"] = x.get_taillight();
+        j["unjealous"] = x.get_unjealous();
+        j["visitorial"] = x.get_visitorial();
+    }
+
+    inline void from_json(json const & j, PotwhiskyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_arciform(get_untyped(j, "arciform"));
+        x.set_cresolin(get_untyped(j, "cresolin"));
+        x.set_disheartener(get_untyped(j, "disheartener"));
+        x.set_disproportionable(get_untyped(j, "disproportionable"));
+        x.set_euchorda(get_untyped(j, "Euchorda"));
+        x.set_ferryway(get_untyped(j, "ferryway"));
+        x.set_filamentiferous(get_untyped(j, "filamentiferous"));
+        x.set_flemish(get_untyped(j, "flemish"));
+        x.set_forgainst(get_untyped(j, "forgainst"));
+        x.set_grainering(get_untyped(j, "grainering"));
+        x.set_irrevoluble(get_untyped(j, "irrevoluble"));
+        x.set_kindredship(get_untyped(j, "kindredship"));
+        x.set_pinguitudinous(get_untyped(j, "pinguitudinous"));
+        x.set_simpletonic(get_untyped(j, "simpletonic"));
+        x.set_singsong(get_untyped(j, "singsong"));
+        x.set_submergement(get_untyped(j, "submergement"));
+        x.set_supraoesophagal(get_untyped(j, "supraoesophagal"));
+        x.set_thrashel(get_untyped(j, "thrashel"));
+        x.set_tyremesis(get_untyped(j, "tyremesis"));
+        x.set_yoruba(get_untyped(j, "Yoruba"));
+    }
+
+    inline void to_json(json & j, PotwhiskyClass const & x) {
+        j = json::object();
+        j["arciform"] = x.get_arciform();
+        j["cresolin"] = x.get_cresolin();
+        j["disheartener"] = x.get_disheartener();
+        j["disproportionable"] = x.get_disproportionable();
+        j["Euchorda"] = x.get_euchorda();
+        j["ferryway"] = x.get_ferryway();
+        j["filamentiferous"] = x.get_filamentiferous();
+        j["flemish"] = x.get_flemish();
+        j["forgainst"] = x.get_forgainst();
+        j["grainering"] = x.get_grainering();
+        j["irrevoluble"] = x.get_irrevoluble();
+        j["kindredship"] = x.get_kindredship();
+        j["pinguitudinous"] = x.get_pinguitudinous();
+        j["simpletonic"] = x.get_simpletonic();
+        j["singsong"] = x.get_singsong();
+        j["submergement"] = x.get_submergement();
+        j["supraoesophagal"] = x.get_supraoesophagal();
+        j["thrashel"] = x.get_thrashel();
+        j["tyremesis"] = x.get_tyremesis();
+        j["Yoruba"] = x.get_yoruba();
+    }
+
+    inline void from_json(json const & j, PrefreshmanClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_azorubine(get_untyped(j, "azorubine"));
+        x.set_choroiditis(get_untyped(j, "choroiditis"));
+        x.set_coagulatory(get_untyped(j, "coagulatory"));
+        x.set_cyclorama(get_untyped(j, "cyclorama"));
+        x.set_dolphus(get_untyped(j, "Dolphus"));
+        x.set_duckhearted(get_untyped(j, "duckhearted"));
+        x.set_ficus(get_untyped(j, "Ficus"));
+        x.set_gemaric(get_untyped(j, "Gemaric"));
+        x.set_jugation(get_untyped(j, "jugation"));
+        x.set_myoliposis(get_untyped(j, "myoliposis"));
+        x.set_nonnomination(get_untyped(j, "nonnomination"));
+        x.set_palay(get_untyped(j, "palay"));
+        x.set_pentactinal(get_untyped(j, "pentactinal"));
+        x.set_phaet(get_untyped(j, "Phaet"));
+        x.set_piquant(get_untyped(j, "piquant"));
+        x.set_registration(get_untyped(j, "registration"));
+        x.set_remancipation(get_untyped(j, "remancipation"));
+        x.set_scutatiform(get_untyped(j, "scutatiform"));
+        x.set_theodolite(get_untyped(j, "theodolite"));
+        x.set_underward(get_untyped(j, "underward"));
+    }
+
+    inline void to_json(json & j, PrefreshmanClass const & x) {
+        j = json::object();
+        j["azorubine"] = x.get_azorubine();
+        j["choroiditis"] = x.get_choroiditis();
+        j["coagulatory"] = x.get_coagulatory();
+        j["cyclorama"] = x.get_cyclorama();
+        j["Dolphus"] = x.get_dolphus();
+        j["duckhearted"] = x.get_duckhearted();
+        j["Ficus"] = x.get_ficus();
+        j["Gemaric"] = x.get_gemaric();
+        j["jugation"] = x.get_jugation();
+        j["myoliposis"] = x.get_myoliposis();
+        j["nonnomination"] = x.get_nonnomination();
+        j["palay"] = x.get_palay();
+        j["pentactinal"] = x.get_pentactinal();
+        j["Phaet"] = x.get_phaet();
+        j["piquant"] = x.get_piquant();
+        j["registration"] = x.get_registration();
+        j["remancipation"] = x.get_remancipation();
+        j["scutatiform"] = x.get_scutatiform();
+        j["theodolite"] = x.get_theodolite();
+        j["underward"] = x.get_underward();
+    }
+
+    inline void from_json(json const & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_juror(j.at("juror").get<std::vector<JurorElement>>());
+        x.set_kongoni(j.at("kongoni").get<std::vector<Kongoni>>());
+        x.set_ladronism(j.at("ladronism").get<std::vector<LadronismElement>>());
+        x.set_landlubberly(j.at("landlubberly").get<std::vector<LandlubberlyElement>>());
+        x.set_listener(j.at("listener").get<std::vector<Listener>>());
+        x.set_lupus(j.at("lupus").get<std::vector<LupusElement>>());
+        x.set_maslin(j.at("maslin").get<std::vector<Maslin>>());
+        x.set_monazite(j.at("monazite").get<std::vector<MonaziteElement>>());
+        x.set_monoliteral(j.at("monoliteral").get<std::vector<Monoliteral>>());
+        x.set_monotheistically(j.at("monotheistically").get<std::vector<MonotheisticallyElement>>());
+        x.set_montage(j.at("montage").get<std::vector<Montage>>());
+        x.set_moralness(j.at("moralness").get<std::vector<Moralness>>());
+        x.set_mowra(j.at("mowra").get<std::vector<std::optional<MonaziteClass>>>());
+        x.set_mulishly(j.at("mulishly").get<std::vector<Mulishly>>());
+        x.set_myoscope(j.at("myoscope").get<std::vector<Myoscope>>());
+        x.set_nach(j.at("nach").get<std::vector<std::optional<std::vector<std::optional<int64_t>>>>>());
+        x.set_neuromastic(j.at("neuromastic").get<std::vector<Neuromastic>>());
+        x.set_noncontributing(j.at("noncontributing").get<std::vector<Noncontributing>>());
+        x.set_nonnervous(j.at("nonnervous").get<std::vector<Nonnervous>>());
+        x.set_nonvaluation(j.at("nonvaluation").get<std::vector<Nonvaluation>>());
+        x.set_occupationalist(j.at("occupationalist").get<std::vector<OccupationalistElement>>());
+        x.set_outrival(j.at("outrival").get<std::vector<OutrivalElement>>());
+        x.set_paleographically(j.at("paleographically").get<std::vector<Paleographically>>());
+        x.set_pamphletwise(j.at("pamphletwise").get<std::vector<Pamphletwise>>());
+        x.set_pediatrics(j.at("pediatrics").get<std::vector<Pediatric>>());
+        x.set_perceptive(j.at("perceptive").get<std::vector<bool>>());
+        x.set_piaculum(j.at("piaculum").get<std::vector<PiaculumElement>>());
+        x.set_piccadilly(j.at("piccadilly").get<std::vector<Piccadilly>>());
+        x.set_piffler(j.at("piffler").get<std::vector<Piffler>>());
+        x.set_pithful(j.at("pithful").get<std::vector<Pithful>>());
+        x.set_placuntitis(j.at("placuntitis").get<std::vector<Placuntiti>>());
+        x.set_plectopterous(j.at("plectopterous").get<std::vector<Plectopterous>>());
+        x.set_pneumocele(j.at("pneumocele").get<std::vector<std::optional<Pneumocele>>>());
+        x.set_poliorcetic(j.at("poliorcetic").get<std::vector<Poliorcetic>>());
+        x.set_poormaster(j.at("poormaster").get<std::vector<Poormaster>>());
+        x.set_potwhisky(j.at("potwhisky").get<std::vector<PotwhiskyElement>>());
+        x.set_practicalizer(j.at("practicalizer").get<std::vector<Practicalizer>>());
+        x.set_prefreshman(j.at("prefreshman").get<std::vector<PrefreshmanElement>>());
+        x.set_prehensility(j.at("prehensility").get<std::vector<Prehensility>>());
+        x.set_prevoidance(j.at("prevoidance").get<std::vector<Prevoidance>>());
+        x.set_probant(j.at("probant").get<std::vector<std::map<std::string, std::optional<int64_t>>>>());
+        x.set_protext(j.at("protext").get<std::vector<Protext>>());
+    }
+
+    inline void to_json(json & j, TopLevel const & x) {
+        j = json::object();
+        j["juror"] = x.get_juror();
+        j["kongoni"] = x.get_kongoni();
+        j["ladronism"] = x.get_ladronism();
+        j["landlubberly"] = x.get_landlubberly();
+        j["listener"] = x.get_listener();
+        j["lupus"] = x.get_lupus();
+        j["maslin"] = x.get_maslin();
+        j["monazite"] = x.get_monazite();
+        j["monoliteral"] = x.get_monoliteral();
+        j["monotheistically"] = x.get_monotheistically();
+        j["montage"] = x.get_montage();
+        j["moralness"] = x.get_moralness();
+        j["mowra"] = x.get_mowra();
+        j["mulishly"] = x.get_mulishly();
+        j["myoscope"] = x.get_myoscope();
+        j["nach"] = x.get_nach();
+        j["neuromastic"] = x.get_neuromastic();
+        j["noncontributing"] = x.get_noncontributing();
+        j["nonnervous"] = x.get_nonnervous();
+        j["nonvaluation"] = x.get_nonvaluation();
+        j["occupationalist"] = x.get_occupationalist();
+        j["outrival"] = x.get_outrival();
+        j["paleographically"] = x.get_paleographically();
+        j["pamphletwise"] = x.get_pamphletwise();
+        j["pediatrics"] = x.get_pediatrics();
+        j["perceptive"] = x.get_perceptive();
+        j["piaculum"] = x.get_piaculum();
+        j["piccadilly"] = x.get_piccadilly();
+        j["piffler"] = x.get_piffler();
+        j["pithful"] = x.get_pithful();
+        j["placuntitis"] = x.get_placuntitis();
+        j["plectopterous"] = x.get_plectopterous();
+        j["pneumocele"] = x.get_pneumocele();
+        j["poliorcetic"] = x.get_poliorcetic();
+        j["poormaster"] = x.get_poormaster();
+        j["potwhisky"] = x.get_potwhisky();
+        j["practicalizer"] = x.get_practicalizer();
+        j["prefreshman"] = x.get_prefreshman();
+        j["prehensility"] = x.get_prehensility();
+        j["prevoidance"] = x.get_prevoidance();
+        j["probant"] = x.get_probant();
+        j["protext"] = x.get_protext();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<bool, quicktype::JurorClass>>::from_json(json const & j, std::variant<bool, quicktype::JurorClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::JurorClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::JurorClass>>::to_json(json & j, std::variant<bool, quicktype::JurorClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::JurorClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>>::from_json(json const & j, std::variant<quicktype::LadronismClass, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::LadronismClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>>::to_json(json & j, std::variant<quicktype::LadronismClass, double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LadronismClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>>::from_json(json const & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::LandlubberlyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>>::to_json(json & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::LandlubberlyClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::from_json(json const & j, std::variant<std::vector<json>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::to_json(json & j, std::variant<std::vector<json>, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LupusClass, int64_t>>::from_json(json const & j, std::variant<quicktype::LupusClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::LupusClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LupusClass, int64_t>>::to_json(json & j, std::variant<quicktype::LupusClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LupusClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MonaziteClass, double>>::from_json(json const & j, std::variant<quicktype::MonaziteClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MonaziteClass, double>>::to_json(json & j, std::variant<quicktype::MonaziteClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::from_json(json const & j, std::variant<std::vector<json>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::to_json(json & j, std::variant<std::vector<json>, bool> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::MonotheisticallyClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>>::to_json(json & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonotheisticallyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::string>>::from_json(json const & j, std::variant<std::vector<json>, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::string>>::to_json(json & j, std::variant<std::vector<json>, double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::from_json(json const & j, std::variant<std::vector<json>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::to_json(json & j, std::variant<std::vector<json>, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(json const & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, std::variant<std::vector<int64_t>, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, int64_t>>::from_json(json const & j, std::variant<std::vector<json>, bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, int64_t>>::to_json(json & j, std::variant<std::vector<json>, bool, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t>>::from_json(json const & j, std::variant<bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t>>::to_json(json & j, std::variant<bool, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, double>>::from_json(json const & j, std::variant<std::vector<json>, bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, double>>::to_json(json & j, std::variant<std::vector<json>, bool, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::OccupationalistClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>>::to_json(json & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::OccupationalistClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OutrivalClass, double>>::from_json(json const & j, std::variant<quicktype::OutrivalClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::OutrivalClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OutrivalClass, double>>::to_json(json & j, std::variant<quicktype::OutrivalClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::OutrivalClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>>::from_json(json const & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(json const & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, std::variant<bool, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PiaculumClass, double>>::from_json(json const & j, std::variant<quicktype::PiaculumClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::PiaculumClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PiaculumClass, double>>::to_json(json & j, std::variant<quicktype::PiaculumClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PiaculumClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(json const & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, std::variant<double, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::MonaziteClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>>::to_json(json & j, std::variant<std::vector<json>, quicktype::MonaziteClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<int64_t, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<double, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::MonaziteClass>>::from_json(json const & j, std::variant<bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::MonaziteClass>>::to_json(json & j, std::variant<bool, quicktype::MonaziteClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>>::from_json(json const & j, std::variant<quicktype::PotwhiskyClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::PotwhiskyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>>::to_json(json & j, std::variant<quicktype::PotwhiskyClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PotwhiskyClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>>::to_json(json & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::PrefreshmanClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>>::to_json(json & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::PrefreshmanClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>>::from_json(json const & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>>::to_json(json & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>>::to_json(json & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations3.json/default/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations3.json/default/quicktype.hpp
new file mode 100644
index 0000000..b6647b6
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations3.json/default/quicktype.hpp
@@ -0,0 +1,3712 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    class JurorClass {
+        public:
+        JurorClass() = default;
+        virtual ~JurorClass() = default;
+
+        private:
+        nlohmann::json adipsy;
+        nlohmann::json auxiliator;
+        nlohmann::json benda;
+        nlohmann::json benjamin;
+        nlohmann::json brandling;
+        nlohmann::json epicurishly;
+        nlohmann::json eremochaetous;
+        nlohmann::json marten;
+        nlohmann::json monocline;
+        nlohmann::json olea;
+        nlohmann::json palgat;
+        nlohmann::json pennyworth;
+        nlohmann::json pioury;
+        nlohmann::json pragmatistic;
+        nlohmann::json stylelessness;
+        nlohmann::json systematical;
+        nlohmann::json thready;
+        nlohmann::json uncontemporary;
+        nlohmann::json uncouched;
+        nlohmann::json uninhabitedness;
+
+        public:
+        const nlohmann::json & get_adipsy() const { return adipsy; }
+        nlohmann::json & get_mutable_adipsy() { return adipsy; }
+        void set_adipsy(const nlohmann::json & value) { this->adipsy = value; }
+
+        const nlohmann::json & get_auxiliator() const { return auxiliator; }
+        nlohmann::json & get_mutable_auxiliator() { return auxiliator; }
+        void set_auxiliator(const nlohmann::json & value) { this->auxiliator = value; }
+
+        const nlohmann::json & get_benda() const { return benda; }
+        nlohmann::json & get_mutable_benda() { return benda; }
+        void set_benda(const nlohmann::json & value) { this->benda = value; }
+
+        const nlohmann::json & get_benjamin() const { return benjamin; }
+        nlohmann::json & get_mutable_benjamin() { return benjamin; }
+        void set_benjamin(const nlohmann::json & value) { this->benjamin = value; }
+
+        const nlohmann::json & get_brandling() const { return brandling; }
+        nlohmann::json & get_mutable_brandling() { return brandling; }
+        void set_brandling(const nlohmann::json & value) { this->brandling = value; }
+
+        const nlohmann::json & get_epicurishly() const { return epicurishly; }
+        nlohmann::json & get_mutable_epicurishly() { return epicurishly; }
+        void set_epicurishly(const nlohmann::json & value) { this->epicurishly = value; }
+
+        const nlohmann::json & get_eremochaetous() const { return eremochaetous; }
+        nlohmann::json & get_mutable_eremochaetous() { return eremochaetous; }
+        void set_eremochaetous(const nlohmann::json & value) { this->eremochaetous = value; }
+
+        const nlohmann::json & get_marten() const { return marten; }
+        nlohmann::json & get_mutable_marten() { return marten; }
+        void set_marten(const nlohmann::json & value) { this->marten = value; }
+
+        const nlohmann::json & get_monocline() const { return monocline; }
+        nlohmann::json & get_mutable_monocline() { return monocline; }
+        void set_monocline(const nlohmann::json & value) { this->monocline = value; }
+
+        const nlohmann::json & get_olea() const { return olea; }
+        nlohmann::json & get_mutable_olea() { return olea; }
+        void set_olea(const nlohmann::json & value) { this->olea = value; }
+
+        const nlohmann::json & get_palgat() const { return palgat; }
+        nlohmann::json & get_mutable_palgat() { return palgat; }
+        void set_palgat(const nlohmann::json & value) { this->palgat = value; }
+
+        const nlohmann::json & get_pennyworth() const { return pennyworth; }
+        nlohmann::json & get_mutable_pennyworth() { return pennyworth; }
+        void set_pennyworth(const nlohmann::json & value) { this->pennyworth = value; }
+
+        const nlohmann::json & get_pioury() const { return pioury; }
+        nlohmann::json & get_mutable_pioury() { return pioury; }
+        void set_pioury(const nlohmann::json & value) { this->pioury = value; }
+
+        const nlohmann::json & get_pragmatistic() const { return pragmatistic; }
+        nlohmann::json & get_mutable_pragmatistic() { return pragmatistic; }
+        void set_pragmatistic(const nlohmann::json & value) { this->pragmatistic = value; }
+
+        const nlohmann::json & get_stylelessness() const { return stylelessness; }
+        nlohmann::json & get_mutable_stylelessness() { return stylelessness; }
+        void set_stylelessness(const nlohmann::json & value) { this->stylelessness = value; }
+
+        const nlohmann::json & get_systematical() const { return systematical; }
+        nlohmann::json & get_mutable_systematical() { return systematical; }
+        void set_systematical(const nlohmann::json & value) { this->systematical = value; }
+
+        const nlohmann::json & get_thready() const { return thready; }
+        nlohmann::json & get_mutable_thready() { return thready; }
+        void set_thready(const nlohmann::json & value) { this->thready = value; }
+
+        const nlohmann::json & get_uncontemporary() const { return uncontemporary; }
+        nlohmann::json & get_mutable_uncontemporary() { return uncontemporary; }
+        void set_uncontemporary(const nlohmann::json & value) { this->uncontemporary = value; }
+
+        const nlohmann::json & get_uncouched() const { return uncouched; }
+        nlohmann::json & get_mutable_uncouched() { return uncouched; }
+        void set_uncouched(const nlohmann::json & value) { this->uncouched = value; }
+
+        const nlohmann::json & get_uninhabitedness() const { return uninhabitedness; }
+        nlohmann::json & get_mutable_uninhabitedness() { return uninhabitedness; }
+        void set_uninhabitedness(const nlohmann::json & value) { this->uninhabitedness = value; }
+    };
+
+    using JurorElement = std::variant<bool, JurorClass>;
+
+    using Kongoni = std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>;
+
+    class LadronismClass {
+        public:
+        LadronismClass() = default;
+        virtual ~LadronismClass() = default;
+
+        private:
+        nlohmann::json acclaimer;
+        nlohmann::json achree;
+        nlohmann::json base;
+        nlohmann::json conundrumize;
+        nlohmann::json degerminator;
+        nlohmann::json describable;
+        nlohmann::json exasperatedly;
+        nlohmann::json heroine;
+        nlohmann::json indazin;
+        nlohmann::json luteous;
+        nlohmann::json papular;
+        nlohmann::json pritch;
+        nlohmann::json prodenia;
+        nlohmann::json seege;
+        nlohmann::json shopgirl;
+        nlohmann::json tragedietta;
+        nlohmann::json unsparse;
+        nlohmann::json uplook;
+        nlohmann::json vermiformis;
+        nlohmann::json whafabout;
+
+        public:
+        const nlohmann::json & get_acclaimer() const { return acclaimer; }
+        nlohmann::json & get_mutable_acclaimer() { return acclaimer; }
+        void set_acclaimer(const nlohmann::json & value) { this->acclaimer = value; }
+
+        const nlohmann::json & get_achree() const { return achree; }
+        nlohmann::json & get_mutable_achree() { return achree; }
+        void set_achree(const nlohmann::json & value) { this->achree = value; }
+
+        const nlohmann::json & get_base() const { return base; }
+        nlohmann::json & get_mutable_base() { return base; }
+        void set_base(const nlohmann::json & value) { this->base = value; }
+
+        const nlohmann::json & get_conundrumize() const { return conundrumize; }
+        nlohmann::json & get_mutable_conundrumize() { return conundrumize; }
+        void set_conundrumize(const nlohmann::json & value) { this->conundrumize = value; }
+
+        const nlohmann::json & get_degerminator() const { return degerminator; }
+        nlohmann::json & get_mutable_degerminator() { return degerminator; }
+        void set_degerminator(const nlohmann::json & value) { this->degerminator = value; }
+
+        const nlohmann::json & get_describable() const { return describable; }
+        nlohmann::json & get_mutable_describable() { return describable; }
+        void set_describable(const nlohmann::json & value) { this->describable = value; }
+
+        const nlohmann::json & get_exasperatedly() const { return exasperatedly; }
+        nlohmann::json & get_mutable_exasperatedly() { return exasperatedly; }
+        void set_exasperatedly(const nlohmann::json & value) { this->exasperatedly = value; }
+
+        const nlohmann::json & get_heroine() const { return heroine; }
+        nlohmann::json & get_mutable_heroine() { return heroine; }
+        void set_heroine(const nlohmann::json & value) { this->heroine = value; }
+
+        const nlohmann::json & get_indazin() const { return indazin; }
+        nlohmann::json & get_mutable_indazin() { return indazin; }
+        void set_indazin(const nlohmann::json & value) { this->indazin = value; }
+
+        const nlohmann::json & get_luteous() const { return luteous; }
+        nlohmann::json & get_mutable_luteous() { return luteous; }
+        void set_luteous(const nlohmann::json & value) { this->luteous = value; }
+
+        const nlohmann::json & get_papular() const { return papular; }
+        nlohmann::json & get_mutable_papular() { return papular; }
+        void set_papular(const nlohmann::json & value) { this->papular = value; }
+
+        const nlohmann::json & get_pritch() const { return pritch; }
+        nlohmann::json & get_mutable_pritch() { return pritch; }
+        void set_pritch(const nlohmann::json & value) { this->pritch = value; }
+
+        const nlohmann::json & get_prodenia() const { return prodenia; }
+        nlohmann::json & get_mutable_prodenia() { return prodenia; }
+        void set_prodenia(const nlohmann::json & value) { this->prodenia = value; }
+
+        const nlohmann::json & get_seege() const { return seege; }
+        nlohmann::json & get_mutable_seege() { return seege; }
+        void set_seege(const nlohmann::json & value) { this->seege = value; }
+
+        const nlohmann::json & get_shopgirl() const { return shopgirl; }
+        nlohmann::json & get_mutable_shopgirl() { return shopgirl; }
+        void set_shopgirl(const nlohmann::json & value) { this->shopgirl = value; }
+
+        const nlohmann::json & get_tragedietta() const { return tragedietta; }
+        nlohmann::json & get_mutable_tragedietta() { return tragedietta; }
+        void set_tragedietta(const nlohmann::json & value) { this->tragedietta = value; }
+
+        const nlohmann::json & get_unsparse() const { return unsparse; }
+        nlohmann::json & get_mutable_unsparse() { return unsparse; }
+        void set_unsparse(const nlohmann::json & value) { this->unsparse = value; }
+
+        const nlohmann::json & get_uplook() const { return uplook; }
+        nlohmann::json & get_mutable_uplook() { return uplook; }
+        void set_uplook(const nlohmann::json & value) { this->uplook = value; }
+
+        const nlohmann::json & get_vermiformis() const { return vermiformis; }
+        nlohmann::json & get_mutable_vermiformis() { return vermiformis; }
+        void set_vermiformis(const nlohmann::json & value) { this->vermiformis = value; }
+
+        const nlohmann::json & get_whafabout() const { return whafabout; }
+        nlohmann::json & get_mutable_whafabout() { return whafabout; }
+        void set_whafabout(const nlohmann::json & value) { this->whafabout = value; }
+    };
+
+    using LadronismElement = std::variant<LadronismClass, double, std::string>;
+
+    class LandlubberlyClass {
+        public:
+        LandlubberlyClass() = default;
+        virtual ~LandlubberlyClass() = default;
+
+        private:
+        nlohmann::json acropoleis;
+        nlohmann::json aminate;
+        nlohmann::json amyraldism;
+        nlohmann::json bipenniform;
+        nlohmann::json bugre;
+        nlohmann::json calycule;
+        nlohmann::json caoutchouc;
+        nlohmann::json disprover;
+        nlohmann::json fitroot;
+        nlohmann::json fulgently;
+        nlohmann::json kickup;
+        nlohmann::json laevoversion;
+        nlohmann::json moter;
+        nlohmann::json objectivity;
+        nlohmann::json posterity;
+        nlohmann::json postnuptial;
+        nlohmann::json precedentary;
+        nlohmann::json saddling;
+        nlohmann::json subcurrent;
+        nlohmann::json unrecriminative;
+
+        public:
+        const nlohmann::json & get_acropoleis() const { return acropoleis; }
+        nlohmann::json & get_mutable_acropoleis() { return acropoleis; }
+        void set_acropoleis(const nlohmann::json & value) { this->acropoleis = value; }
+
+        const nlohmann::json & get_aminate() const { return aminate; }
+        nlohmann::json & get_mutable_aminate() { return aminate; }
+        void set_aminate(const nlohmann::json & value) { this->aminate = value; }
+
+        const nlohmann::json & get_amyraldism() const { return amyraldism; }
+        nlohmann::json & get_mutable_amyraldism() { return amyraldism; }
+        void set_amyraldism(const nlohmann::json & value) { this->amyraldism = value; }
+
+        const nlohmann::json & get_bipenniform() const { return bipenniform; }
+        nlohmann::json & get_mutable_bipenniform() { return bipenniform; }
+        void set_bipenniform(const nlohmann::json & value) { this->bipenniform = value; }
+
+        const nlohmann::json & get_bugre() const { return bugre; }
+        nlohmann::json & get_mutable_bugre() { return bugre; }
+        void set_bugre(const nlohmann::json & value) { this->bugre = value; }
+
+        const nlohmann::json & get_calycule() const { return calycule; }
+        nlohmann::json & get_mutable_calycule() { return calycule; }
+        void set_calycule(const nlohmann::json & value) { this->calycule = value; }
+
+        const nlohmann::json & get_caoutchouc() const { return caoutchouc; }
+        nlohmann::json & get_mutable_caoutchouc() { return caoutchouc; }
+        void set_caoutchouc(const nlohmann::json & value) { this->caoutchouc = value; }
+
+        const nlohmann::json & get_disprover() const { return disprover; }
+        nlohmann::json & get_mutable_disprover() { return disprover; }
+        void set_disprover(const nlohmann::json & value) { this->disprover = value; }
+
+        const nlohmann::json & get_fitroot() const { return fitroot; }
+        nlohmann::json & get_mutable_fitroot() { return fitroot; }
+        void set_fitroot(const nlohmann::json & value) { this->fitroot = value; }
+
+        const nlohmann::json & get_fulgently() const { return fulgently; }
+        nlohmann::json & get_mutable_fulgently() { return fulgently; }
+        void set_fulgently(const nlohmann::json & value) { this->fulgently = value; }
+
+        const nlohmann::json & get_kickup() const { return kickup; }
+        nlohmann::json & get_mutable_kickup() { return kickup; }
+        void set_kickup(const nlohmann::json & value) { this->kickup = value; }
+
+        const nlohmann::json & get_laevoversion() const { return laevoversion; }
+        nlohmann::json & get_mutable_laevoversion() { return laevoversion; }
+        void set_laevoversion(const nlohmann::json & value) { this->laevoversion = value; }
+
+        const nlohmann::json & get_moter() const { return moter; }
+        nlohmann::json & get_mutable_moter() { return moter; }
+        void set_moter(const nlohmann::json & value) { this->moter = value; }
+
+        const nlohmann::json & get_objectivity() const { return objectivity; }
+        nlohmann::json & get_mutable_objectivity() { return objectivity; }
+        void set_objectivity(const nlohmann::json & value) { this->objectivity = value; }
+
+        const nlohmann::json & get_posterity() const { return posterity; }
+        nlohmann::json & get_mutable_posterity() { return posterity; }
+        void set_posterity(const nlohmann::json & value) { this->posterity = value; }
+
+        const nlohmann::json & get_postnuptial() const { return postnuptial; }
+        nlohmann::json & get_mutable_postnuptial() { return postnuptial; }
+        void set_postnuptial(const nlohmann::json & value) { this->postnuptial = value; }
+
+        const nlohmann::json & get_precedentary() const { return precedentary; }
+        nlohmann::json & get_mutable_precedentary() { return precedentary; }
+        void set_precedentary(const nlohmann::json & value) { this->precedentary = value; }
+
+        const nlohmann::json & get_saddling() const { return saddling; }
+        nlohmann::json & get_mutable_saddling() { return saddling; }
+        void set_saddling(const nlohmann::json & value) { this->saddling = value; }
+
+        const nlohmann::json & get_subcurrent() const { return subcurrent; }
+        nlohmann::json & get_mutable_subcurrent() { return subcurrent; }
+        void set_subcurrent(const nlohmann::json & value) { this->subcurrent = value; }
+
+        const nlohmann::json & get_unrecriminative() const { return unrecriminative; }
+        nlohmann::json & get_mutable_unrecriminative() { return unrecriminative; }
+        void set_unrecriminative(const nlohmann::json & value) { this->unrecriminative = value; }
+    };
+
+    using LandlubberlyElement = std::variant<bool, LandlubberlyClass, int64_t>;
+
+    using Listener = std::variant<std::vector<nlohmann::json>, int64_t>;
+
+    class LupusClass {
+        public:
+        LupusClass() = default;
+        virtual ~LupusClass() = default;
+
+        private:
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chlorioninae;
+        std::optional<int64_t> corvinae;
+        std::optional<int64_t> crassina;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> exiguity;
+        std::optional<int64_t> farcist;
+        std::optional<int64_t> holographical;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> ichthyophagan;
+        std::optional<int64_t> implacable;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> outshiner;
+        std::optional<int64_t> overweather;
+        std::optional<int64_t> protonegroid;
+        std::optional<int64_t> shallowish;
+        std::optional<int64_t> snoke;
+        std::optional<int64_t> snout;
+        std::optional<int64_t> surveillance;
+        std::optional<int64_t> threshingtime;
+        std::optional<int64_t> thysanocarpus;
+        std::optional<int64_t> unsignificantly;
+        std::optional<int64_t> unsnap;
+        std::optional<int64_t> vendible;
+
+        public:
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_chlorioninae() const { return chlorioninae; }
+        std::optional<int64_t> & get_mutable_chlorioninae() { return chlorioninae; }
+        void set_chlorioninae(const std::optional<int64_t> & value) { this->chlorioninae = value; }
+
+        const std::optional<int64_t> & get_corvinae() const { return corvinae; }
+        std::optional<int64_t> & get_mutable_corvinae() { return corvinae; }
+        void set_corvinae(const std::optional<int64_t> & value) { this->corvinae = value; }
+
+        const std::optional<int64_t> & get_crassina() const { return crassina; }
+        std::optional<int64_t> & get_mutable_crassina() { return crassina; }
+        void set_crassina(const std::optional<int64_t> & value) { this->crassina = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_exiguity() const { return exiguity; }
+        std::optional<int64_t> & get_mutable_exiguity() { return exiguity; }
+        void set_exiguity(const std::optional<int64_t> & value) { this->exiguity = value; }
+
+        const std::optional<int64_t> & get_farcist() const { return farcist; }
+        std::optional<int64_t> & get_mutable_farcist() { return farcist; }
+        void set_farcist(const std::optional<int64_t> & value) { this->farcist = value; }
+
+        const std::optional<int64_t> & get_holographical() const { return holographical; }
+        std::optional<int64_t> & get_mutable_holographical() { return holographical; }
+        void set_holographical(const std::optional<int64_t> & value) { this->holographical = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_ichthyophagan() const { return ichthyophagan; }
+        std::optional<int64_t> & get_mutable_ichthyophagan() { return ichthyophagan; }
+        void set_ichthyophagan(const std::optional<int64_t> & value) { this->ichthyophagan = value; }
+
+        const std::optional<int64_t> & get_implacable() const { return implacable; }
+        std::optional<int64_t> & get_mutable_implacable() { return implacable; }
+        void set_implacable(const std::optional<int64_t> & value) { this->implacable = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_outshiner() const { return outshiner; }
+        std::optional<int64_t> & get_mutable_outshiner() { return outshiner; }
+        void set_outshiner(const std::optional<int64_t> & value) { this->outshiner = value; }
+
+        const std::optional<int64_t> & get_overweather() const { return overweather; }
+        std::optional<int64_t> & get_mutable_overweather() { return overweather; }
+        void set_overweather(const std::optional<int64_t> & value) { this->overweather = value; }
+
+        const std::optional<int64_t> & get_protonegroid() const { return protonegroid; }
+        std::optional<int64_t> & get_mutable_protonegroid() { return protonegroid; }
+        void set_protonegroid(const std::optional<int64_t> & value) { this->protonegroid = value; }
+
+        const std::optional<int64_t> & get_shallowish() const { return shallowish; }
+        std::optional<int64_t> & get_mutable_shallowish() { return shallowish; }
+        void set_shallowish(const std::optional<int64_t> & value) { this->shallowish = value; }
+
+        const std::optional<int64_t> & get_snoke() const { return snoke; }
+        std::optional<int64_t> & get_mutable_snoke() { return snoke; }
+        void set_snoke(const std::optional<int64_t> & value) { this->snoke = value; }
+
+        const std::optional<int64_t> & get_snout() const { return snout; }
+        std::optional<int64_t> & get_mutable_snout() { return snout; }
+        void set_snout(const std::optional<int64_t> & value) { this->snout = value; }
+
+        const std::optional<int64_t> & get_surveillance() const { return surveillance; }
+        std::optional<int64_t> & get_mutable_surveillance() { return surveillance; }
+        void set_surveillance(const std::optional<int64_t> & value) { this->surveillance = value; }
+
+        const std::optional<int64_t> & get_threshingtime() const { return threshingtime; }
+        std::optional<int64_t> & get_mutable_threshingtime() { return threshingtime; }
+        void set_threshingtime(const std::optional<int64_t> & value) { this->threshingtime = value; }
+
+        const std::optional<int64_t> & get_thysanocarpus() const { return thysanocarpus; }
+        std::optional<int64_t> & get_mutable_thysanocarpus() { return thysanocarpus; }
+        void set_thysanocarpus(const std::optional<int64_t> & value) { this->thysanocarpus = value; }
+
+        const std::optional<int64_t> & get_unsignificantly() const { return unsignificantly; }
+        std::optional<int64_t> & get_mutable_unsignificantly() { return unsignificantly; }
+        void set_unsignificantly(const std::optional<int64_t> & value) { this->unsignificantly = value; }
+
+        const std::optional<int64_t> & get_unsnap() const { return unsnap; }
+        std::optional<int64_t> & get_mutable_unsnap() { return unsnap; }
+        void set_unsnap(const std::optional<int64_t> & value) { this->unsnap = value; }
+
+        const std::optional<int64_t> & get_vendible() const { return vendible; }
+        std::optional<int64_t> & get_mutable_vendible() { return vendible; }
+        void set_vendible(const std::optional<int64_t> & value) { this->vendible = value; }
+    };
+
+    using LupusElement = std::variant<LupusClass, int64_t>;
+
+    class Maslin {
+        public:
+        Maslin() = default;
+        virtual ~Maslin() = default;
+
+        private:
+        std::optional<int64_t> alicant;
+        nlohmann::json antiatonement;
+        std::optional<int64_t> anticorrosive;
+        nlohmann::json aphidozer;
+        nlohmann::json bakuninist;
+        std::optional<int64_t> be;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chub;
+        std::optional<int64_t> cuprosilicon;
+        std::optional<int64_t> curtailedly;
+        std::optional<int64_t> dellenite;
+        std::optional<int64_t> dimitry;
+        std::optional<std::string> disdiapason;
+        nlohmann::json edifying;
+        std::optional<int64_t> ethmoiditis;
+        nlohmann::json gastralgy;
+        std::optional<int64_t> goatherd;
+        std::optional<int64_t> hammerdress;
+        nlohmann::json hangfire;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> lacunosity;
+        nlohmann::json longiloquence;
+        std::optional<int64_t> mameliere;
+        nlohmann::json motherless;
+        nlohmann::json nonbookish;
+        nlohmann::json noncorrodible;
+        nlohmann::json nonsensicality;
+        std::optional<int64_t> oafishly;
+        nlohmann::json pfund;
+        nlohmann::json preadvisory;
+        nlohmann::json retroflexed;
+        std::optional<int64_t> saccharulmic;
+        std::optional<int64_t> scowlful;
+        nlohmann::json secluded;
+        nlohmann::json slackage;
+        std::optional<int64_t> sphaeridial;
+        nlohmann::json spondulics;
+        std::optional<int64_t> subsecive;
+        nlohmann::json swellmobsman;
+        std::optional<int64_t> trachyglossate;
+        nlohmann::json trialogue;
+        std::optional<int64_t> unassuaged;
+        nlohmann::json ungross;
+        nlohmann::json unjudiciously;
+
+        public:
+        const std::optional<int64_t> & get_alicant() const { return alicant; }
+        std::optional<int64_t> & get_mutable_alicant() { return alicant; }
+        void set_alicant(const std::optional<int64_t> & value) { this->alicant = value; }
+
+        const nlohmann::json & get_antiatonement() const { return antiatonement; }
+        nlohmann::json & get_mutable_antiatonement() { return antiatonement; }
+        void set_antiatonement(const nlohmann::json & value) { this->antiatonement = value; }
+
+        const std::optional<int64_t> & get_anticorrosive() const { return anticorrosive; }
+        std::optional<int64_t> & get_mutable_anticorrosive() { return anticorrosive; }
+        void set_anticorrosive(const std::optional<int64_t> & value) { this->anticorrosive = value; }
+
+        const nlohmann::json & get_aphidozer() const { return aphidozer; }
+        nlohmann::json & get_mutable_aphidozer() { return aphidozer; }
+        void set_aphidozer(const nlohmann::json & value) { this->aphidozer = value; }
+
+        const nlohmann::json & get_bakuninist() const { return bakuninist; }
+        nlohmann::json & get_mutable_bakuninist() { return bakuninist; }
+        void set_bakuninist(const nlohmann::json & value) { this->bakuninist = value; }
+
+        const std::optional<int64_t> & get_be() const { return be; }
+        std::optional<int64_t> & get_mutable_be() { return be; }
+        void set_be(const std::optional<int64_t> & value) { this->be = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_chub() const { return chub; }
+        std::optional<int64_t> & get_mutable_chub() { return chub; }
+        void set_chub(const std::optional<int64_t> & value) { this->chub = value; }
+
+        const std::optional<int64_t> & get_cuprosilicon() const { return cuprosilicon; }
+        std::optional<int64_t> & get_mutable_cuprosilicon() { return cuprosilicon; }
+        void set_cuprosilicon(const std::optional<int64_t> & value) { this->cuprosilicon = value; }
+
+        const std::optional<int64_t> & get_curtailedly() const { return curtailedly; }
+        std::optional<int64_t> & get_mutable_curtailedly() { return curtailedly; }
+        void set_curtailedly(const std::optional<int64_t> & value) { this->curtailedly = value; }
+
+        const std::optional<int64_t> & get_dellenite() const { return dellenite; }
+        std::optional<int64_t> & get_mutable_dellenite() { return dellenite; }
+        void set_dellenite(const std::optional<int64_t> & value) { this->dellenite = value; }
+
+        const std::optional<int64_t> & get_dimitry() const { return dimitry; }
+        std::optional<int64_t> & get_mutable_dimitry() { return dimitry; }
+        void set_dimitry(const std::optional<int64_t> & value) { this->dimitry = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_edifying() const { return edifying; }
+        nlohmann::json & get_mutable_edifying() { return edifying; }
+        void set_edifying(const nlohmann::json & value) { this->edifying = value; }
+
+        const std::optional<int64_t> & get_ethmoiditis() const { return ethmoiditis; }
+        std::optional<int64_t> & get_mutable_ethmoiditis() { return ethmoiditis; }
+        void set_ethmoiditis(const std::optional<int64_t> & value) { this->ethmoiditis = value; }
+
+        const nlohmann::json & get_gastralgy() const { return gastralgy; }
+        nlohmann::json & get_mutable_gastralgy() { return gastralgy; }
+        void set_gastralgy(const nlohmann::json & value) { this->gastralgy = value; }
+
+        const std::optional<int64_t> & get_goatherd() const { return goatherd; }
+        std::optional<int64_t> & get_mutable_goatherd() { return goatherd; }
+        void set_goatherd(const std::optional<int64_t> & value) { this->goatherd = value; }
+
+        const std::optional<int64_t> & get_hammerdress() const { return hammerdress; }
+        std::optional<int64_t> & get_mutable_hammerdress() { return hammerdress; }
+        void set_hammerdress(const std::optional<int64_t> & value) { this->hammerdress = value; }
+
+        const nlohmann::json & get_hangfire() const { return hangfire; }
+        nlohmann::json & get_mutable_hangfire() { return hangfire; }
+        void set_hangfire(const nlohmann::json & value) { this->hangfire = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_lacunosity() const { return lacunosity; }
+        std::optional<int64_t> & get_mutable_lacunosity() { return lacunosity; }
+        void set_lacunosity(const std::optional<int64_t> & value) { this->lacunosity = value; }
+
+        const nlohmann::json & get_longiloquence() const { return longiloquence; }
+        nlohmann::json & get_mutable_longiloquence() { return longiloquence; }
+        void set_longiloquence(const nlohmann::json & value) { this->longiloquence = value; }
+
+        const std::optional<int64_t> & get_mameliere() const { return mameliere; }
+        std::optional<int64_t> & get_mutable_mameliere() { return mameliere; }
+        void set_mameliere(const std::optional<int64_t> & value) { this->mameliere = value; }
+
+        const nlohmann::json & get_motherless() const { return motherless; }
+        nlohmann::json & get_mutable_motherless() { return motherless; }
+        void set_motherless(const nlohmann::json & value) { this->motherless = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_noncorrodible() const { return noncorrodible; }
+        nlohmann::json & get_mutable_noncorrodible() { return noncorrodible; }
+        void set_noncorrodible(const nlohmann::json & value) { this->noncorrodible = value; }
+
+        const nlohmann::json & get_nonsensicality() const { return nonsensicality; }
+        nlohmann::json & get_mutable_nonsensicality() { return nonsensicality; }
+        void set_nonsensicality(const nlohmann::json & value) { this->nonsensicality = value; }
+
+        const std::optional<int64_t> & get_oafishly() const { return oafishly; }
+        std::optional<int64_t> & get_mutable_oafishly() { return oafishly; }
+        void set_oafishly(const std::optional<int64_t> & value) { this->oafishly = value; }
+
+        const nlohmann::json & get_pfund() const { return pfund; }
+        nlohmann::json & get_mutable_pfund() { return pfund; }
+        void set_pfund(const nlohmann::json & value) { this->pfund = value; }
+
+        const nlohmann::json & get_preadvisory() const { return preadvisory; }
+        nlohmann::json & get_mutable_preadvisory() { return preadvisory; }
+        void set_preadvisory(const nlohmann::json & value) { this->preadvisory = value; }
+
+        const nlohmann::json & get_retroflexed() const { return retroflexed; }
+        nlohmann::json & get_mutable_retroflexed() { return retroflexed; }
+        void set_retroflexed(const nlohmann::json & value) { this->retroflexed = value; }
+
+        const std::optional<int64_t> & get_saccharulmic() const { return saccharulmic; }
+        std::optional<int64_t> & get_mutable_saccharulmic() { return saccharulmic; }
+        void set_saccharulmic(const std::optional<int64_t> & value) { this->saccharulmic = value; }
+
+        const std::optional<int64_t> & get_scowlful() const { return scowlful; }
+        std::optional<int64_t> & get_mutable_scowlful() { return scowlful; }
+        void set_scowlful(const std::optional<int64_t> & value) { this->scowlful = value; }
+
+        const nlohmann::json & get_secluded() const { return secluded; }
+        nlohmann::json & get_mutable_secluded() { return secluded; }
+        void set_secluded(const nlohmann::json & value) { this->secluded = value; }
+
+        const nlohmann::json & get_slackage() const { return slackage; }
+        nlohmann::json & get_mutable_slackage() { return slackage; }
+        void set_slackage(const nlohmann::json & value) { this->slackage = value; }
+
+        const std::optional<int64_t> & get_sphaeridial() const { return sphaeridial; }
+        std::optional<int64_t> & get_mutable_sphaeridial() { return sphaeridial; }
+        void set_sphaeridial(const std::optional<int64_t> & value) { this->sphaeridial = value; }
+
+        const nlohmann::json & get_spondulics() const { return spondulics; }
+        nlohmann::json & get_mutable_spondulics() { return spondulics; }
+        void set_spondulics(const nlohmann::json & value) { this->spondulics = value; }
+
+        const std::optional<int64_t> & get_subsecive() const { return subsecive; }
+        std::optional<int64_t> & get_mutable_subsecive() { return subsecive; }
+        void set_subsecive(const std::optional<int64_t> & value) { this->subsecive = value; }
+
+        const nlohmann::json & get_swellmobsman() const { return swellmobsman; }
+        nlohmann::json & get_mutable_swellmobsman() { return swellmobsman; }
+        void set_swellmobsman(const nlohmann::json & value) { this->swellmobsman = value; }
+
+        const std::optional<int64_t> & get_trachyglossate() const { return trachyglossate; }
+        std::optional<int64_t> & get_mutable_trachyglossate() { return trachyglossate; }
+        void set_trachyglossate(const std::optional<int64_t> & value) { this->trachyglossate = value; }
+
+        const nlohmann::json & get_trialogue() const { return trialogue; }
+        nlohmann::json & get_mutable_trialogue() { return trialogue; }
+        void set_trialogue(const nlohmann::json & value) { this->trialogue = value; }
+
+        const std::optional<int64_t> & get_unassuaged() const { return unassuaged; }
+        std::optional<int64_t> & get_mutable_unassuaged() { return unassuaged; }
+        void set_unassuaged(const std::optional<int64_t> & value) { this->unassuaged = value; }
+
+        const nlohmann::json & get_ungross() const { return ungross; }
+        nlohmann::json & get_mutable_ungross() { return ungross; }
+        void set_ungross(const nlohmann::json & value) { this->ungross = value; }
+
+        const nlohmann::json & get_unjudiciously() const { return unjudiciously; }
+        nlohmann::json & get_mutable_unjudiciously() { return unjudiciously; }
+        void set_unjudiciously(const nlohmann::json & value) { this->unjudiciously = value; }
+    };
+
+    class MonaziteClass {
+        public:
+        MonaziteClass() = default;
+        virtual ~MonaziteClass() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        const double & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const double & value) { this->catharticalness = value; }
+
+        const int64_t & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const int64_t & value) { this->chirotherium = value; }
+
+        const std::string & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::string & value) { this->disdiapason = value; }
+
+        const bool & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const bool & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+    };
+
+    using MonaziteElement = std::variant<MonaziteClass, double>;
+
+    using Monoliteral = std::variant<std::vector<nlohmann::json>, bool>;
+
+    class MonotheisticallyClass {
+        public:
+        MonotheisticallyClass() = default;
+        virtual ~MonotheisticallyClass() = default;
+
+        private:
+        nlohmann::json blaspheme;
+        std::optional<double> catharticalness;
+        nlohmann::json celiosalpingectomy;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json consummativeness;
+        std::optional<std::string> disdiapason;
+        nlohmann::json egestive;
+        nlohmann::json enchylema;
+        nlohmann::json gasconade;
+        nlohmann::json holidayer;
+        std::optional<bool> homocerc;
+        nlohmann::json intuitionalism;
+        nlohmann::json lophiostomate;
+        nlohmann::json nonbookish;
+        nlohmann::json nonvolition;
+        nlohmann::json palatableness;
+        nlohmann::json pimpery;
+        nlohmann::json previolation;
+        nlohmann::json reconveyance;
+        nlohmann::json registership;
+        nlohmann::json rhyacolite;
+        nlohmann::json smithereens;
+        nlohmann::json superedification;
+        nlohmann::json trust;
+        nlohmann::json whitestone;
+
+        public:
+        const nlohmann::json & get_blaspheme() const { return blaspheme; }
+        nlohmann::json & get_mutable_blaspheme() { return blaspheme; }
+        void set_blaspheme(const nlohmann::json & value) { this->blaspheme = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const nlohmann::json & get_celiosalpingectomy() const { return celiosalpingectomy; }
+        nlohmann::json & get_mutable_celiosalpingectomy() { return celiosalpingectomy; }
+        void set_celiosalpingectomy(const nlohmann::json & value) { this->celiosalpingectomy = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const nlohmann::json & get_consummativeness() const { return consummativeness; }
+        nlohmann::json & get_mutable_consummativeness() { return consummativeness; }
+        void set_consummativeness(const nlohmann::json & value) { this->consummativeness = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_egestive() const { return egestive; }
+        nlohmann::json & get_mutable_egestive() { return egestive; }
+        void set_egestive(const nlohmann::json & value) { this->egestive = value; }
+
+        const nlohmann::json & get_enchylema() const { return enchylema; }
+        nlohmann::json & get_mutable_enchylema() { return enchylema; }
+        void set_enchylema(const nlohmann::json & value) { this->enchylema = value; }
+
+        const nlohmann::json & get_gasconade() const { return gasconade; }
+        nlohmann::json & get_mutable_gasconade() { return gasconade; }
+        void set_gasconade(const nlohmann::json & value) { this->gasconade = value; }
+
+        const nlohmann::json & get_holidayer() const { return holidayer; }
+        nlohmann::json & get_mutable_holidayer() { return holidayer; }
+        void set_holidayer(const nlohmann::json & value) { this->holidayer = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_intuitionalism() const { return intuitionalism; }
+        nlohmann::json & get_mutable_intuitionalism() { return intuitionalism; }
+        void set_intuitionalism(const nlohmann::json & value) { this->intuitionalism = value; }
+
+        const nlohmann::json & get_lophiostomate() const { return lophiostomate; }
+        nlohmann::json & get_mutable_lophiostomate() { return lophiostomate; }
+        void set_lophiostomate(const nlohmann::json & value) { this->lophiostomate = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_nonvolition() const { return nonvolition; }
+        nlohmann::json & get_mutable_nonvolition() { return nonvolition; }
+        void set_nonvolition(const nlohmann::json & value) { this->nonvolition = value; }
+
+        const nlohmann::json & get_palatableness() const { return palatableness; }
+        nlohmann::json & get_mutable_palatableness() { return palatableness; }
+        void set_palatableness(const nlohmann::json & value) { this->palatableness = value; }
+
+        const nlohmann::json & get_pimpery() const { return pimpery; }
+        nlohmann::json & get_mutable_pimpery() { return pimpery; }
+        void set_pimpery(const nlohmann::json & value) { this->pimpery = value; }
+
+        const nlohmann::json & get_previolation() const { return previolation; }
+        nlohmann::json & get_mutable_previolation() { return previolation; }
+        void set_previolation(const nlohmann::json & value) { this->previolation = value; }
+
+        const nlohmann::json & get_reconveyance() const { return reconveyance; }
+        nlohmann::json & get_mutable_reconveyance() { return reconveyance; }
+        void set_reconveyance(const nlohmann::json & value) { this->reconveyance = value; }
+
+        const nlohmann::json & get_registership() const { return registership; }
+        nlohmann::json & get_mutable_registership() { return registership; }
+        void set_registership(const nlohmann::json & value) { this->registership = value; }
+
+        const nlohmann::json & get_rhyacolite() const { return rhyacolite; }
+        nlohmann::json & get_mutable_rhyacolite() { return rhyacolite; }
+        void set_rhyacolite(const nlohmann::json & value) { this->rhyacolite = value; }
+
+        const nlohmann::json & get_smithereens() const { return smithereens; }
+        nlohmann::json & get_mutable_smithereens() { return smithereens; }
+        void set_smithereens(const nlohmann::json & value) { this->smithereens = value; }
+
+        const nlohmann::json & get_superedification() const { return superedification; }
+        nlohmann::json & get_mutable_superedification() { return superedification; }
+        void set_superedification(const nlohmann::json & value) { this->superedification = value; }
+
+        const nlohmann::json & get_trust() const { return trust; }
+        nlohmann::json & get_mutable_trust() { return trust; }
+        void set_trust(const nlohmann::json & value) { this->trust = value; }
+
+        const nlohmann::json & get_whitestone() const { return whitestone; }
+        nlohmann::json & get_mutable_whitestone() { return whitestone; }
+        void set_whitestone(const nlohmann::json & value) { this->whitestone = value; }
+    };
+
+    using MonotheisticallyElement = std::variant<std::vector<nlohmann::json>, MonotheisticallyClass>;
+
+    using Montage = std::variant<std::vector<nlohmann::json>, double, std::string>;
+
+    using Moralness = std::optional<std::variant<std::vector<nlohmann::json>, double>>;
+
+    using Mulishly = std::optional<std::variant<std::vector<int64_t>, double>>;
+
+    using Myoscope = std::variant<std::vector<nlohmann::json>, bool, int64_t>;
+
+    using Neuromastic = std::variant<std::vector<nlohmann::json>, double>;
+
+    class Noncontributing {
+        public:
+        Noncontributing() = default;
+        virtual ~Noncontributing() = default;
+
+        private:
+        std::string estevin;
+        double jolterhead;
+        int64_t sauternes;
+        bool sparsely;
+        nlohmann::json unrequested;
+
+        public:
+        const std::string & get_estevin() const { return estevin; }
+        std::string & get_mutable_estevin() { return estevin; }
+        void set_estevin(const std::string & value) { this->estevin = value; }
+
+        const double & get_jolterhead() const { return jolterhead; }
+        double & get_mutable_jolterhead() { return jolterhead; }
+        void set_jolterhead(const double & value) { this->jolterhead = value; }
+
+        const int64_t & get_sauternes() const { return sauternes; }
+        int64_t & get_mutable_sauternes() { return sauternes; }
+        void set_sauternes(const int64_t & value) { this->sauternes = value; }
+
+        const bool & get_sparsely() const { return sparsely; }
+        bool & get_mutable_sparsely() { return sparsely; }
+        void set_sparsely(const bool & value) { this->sparsely = value; }
+
+        const nlohmann::json & get_unrequested() const { return unrequested; }
+        nlohmann::json & get_mutable_unrequested() { return unrequested; }
+        void set_unrequested(const nlohmann::json & value) { this->unrequested = value; }
+    };
+
+    using Nonnervous = std::variant<bool, int64_t>;
+
+    using Nonvaluation = std::variant<std::vector<nlohmann::json>, bool, double>;
+
+    class OccupationalistClass {
+        public:
+        OccupationalistClass() = default;
+        virtual ~OccupationalistClass() = default;
+
+        private:
+        nlohmann::json beholdable;
+        nlohmann::json brotuliform;
+        nlohmann::json chimakum;
+        nlohmann::json doodler;
+        nlohmann::json emulsin;
+        nlohmann::json fin;
+        nlohmann::json flourishing;
+        nlohmann::json flueless;
+        nlohmann::json furtively;
+        nlohmann::json gritter;
+        nlohmann::json interwish;
+        nlohmann::json monoxylic;
+        nlohmann::json myristic;
+        nlohmann::json nightwear;
+        nlohmann::json peruser;
+        nlohmann::json theoastrological;
+        nlohmann::json thumby;
+        nlohmann::json tingitid;
+        nlohmann::json trailless;
+        nlohmann::json unpocketed;
+
+        public:
+        const nlohmann::json & get_beholdable() const { return beholdable; }
+        nlohmann::json & get_mutable_beholdable() { return beholdable; }
+        void set_beholdable(const nlohmann::json & value) { this->beholdable = value; }
+
+        const nlohmann::json & get_brotuliform() const { return brotuliform; }
+        nlohmann::json & get_mutable_brotuliform() { return brotuliform; }
+        void set_brotuliform(const nlohmann::json & value) { this->brotuliform = value; }
+
+        const nlohmann::json & get_chimakum() const { return chimakum; }
+        nlohmann::json & get_mutable_chimakum() { return chimakum; }
+        void set_chimakum(const nlohmann::json & value) { this->chimakum = value; }
+
+        const nlohmann::json & get_doodler() const { return doodler; }
+        nlohmann::json & get_mutable_doodler() { return doodler; }
+        void set_doodler(const nlohmann::json & value) { this->doodler = value; }
+
+        const nlohmann::json & get_emulsin() const { return emulsin; }
+        nlohmann::json & get_mutable_emulsin() { return emulsin; }
+        void set_emulsin(const nlohmann::json & value) { this->emulsin = value; }
+
+        const nlohmann::json & get_fin() const { return fin; }
+        nlohmann::json & get_mutable_fin() { return fin; }
+        void set_fin(const nlohmann::json & value) { this->fin = value; }
+
+        const nlohmann::json & get_flourishing() const { return flourishing; }
+        nlohmann::json & get_mutable_flourishing() { return flourishing; }
+        void set_flourishing(const nlohmann::json & value) { this->flourishing = value; }
+
+        const nlohmann::json & get_flueless() const { return flueless; }
+        nlohmann::json & get_mutable_flueless() { return flueless; }
+        void set_flueless(const nlohmann::json & value) { this->flueless = value; }
+
+        const nlohmann::json & get_furtively() const { return furtively; }
+        nlohmann::json & get_mutable_furtively() { return furtively; }
+        void set_furtively(const nlohmann::json & value) { this->furtively = value; }
+
+        const nlohmann::json & get_gritter() const { return gritter; }
+        nlohmann::json & get_mutable_gritter() { return gritter; }
+        void set_gritter(const nlohmann::json & value) { this->gritter = value; }
+
+        const nlohmann::json & get_interwish() const { return interwish; }
+        nlohmann::json & get_mutable_interwish() { return interwish; }
+        void set_interwish(const nlohmann::json & value) { this->interwish = value; }
+
+        const nlohmann::json & get_monoxylic() const { return monoxylic; }
+        nlohmann::json & get_mutable_monoxylic() { return monoxylic; }
+        void set_monoxylic(const nlohmann::json & value) { this->monoxylic = value; }
+
+        const nlohmann::json & get_myristic() const { return myristic; }
+        nlohmann::json & get_mutable_myristic() { return myristic; }
+        void set_myristic(const nlohmann::json & value) { this->myristic = value; }
+
+        const nlohmann::json & get_nightwear() const { return nightwear; }
+        nlohmann::json & get_mutable_nightwear() { return nightwear; }
+        void set_nightwear(const nlohmann::json & value) { this->nightwear = value; }
+
+        const nlohmann::json & get_peruser() const { return peruser; }
+        nlohmann::json & get_mutable_peruser() { return peruser; }
+        void set_peruser(const nlohmann::json & value) { this->peruser = value; }
+
+        const nlohmann::json & get_theoastrological() const { return theoastrological; }
+        nlohmann::json & get_mutable_theoastrological() { return theoastrological; }
+        void set_theoastrological(const nlohmann::json & value) { this->theoastrological = value; }
+
+        const nlohmann::json & get_thumby() const { return thumby; }
+        nlohmann::json & get_mutable_thumby() { return thumby; }
+        void set_thumby(const nlohmann::json & value) { this->thumby = value; }
+
+        const nlohmann::json & get_tingitid() const { return tingitid; }
+        nlohmann::json & get_mutable_tingitid() { return tingitid; }
+        void set_tingitid(const nlohmann::json & value) { this->tingitid = value; }
+
+        const nlohmann::json & get_trailless() const { return trailless; }
+        nlohmann::json & get_mutable_trailless() { return trailless; }
+        void set_trailless(const nlohmann::json & value) { this->trailless = value; }
+
+        const nlohmann::json & get_unpocketed() const { return unpocketed; }
+        nlohmann::json & get_mutable_unpocketed() { return unpocketed; }
+        void set_unpocketed(const nlohmann::json & value) { this->unpocketed = value; }
+    };
+
+    using OccupationalistElement = std::optional<std::variant<std::vector<nlohmann::json>, OccupationalistClass>>;
+
+    class OutrivalClass {
+        public:
+        OutrivalClass() = default;
+        virtual ~OutrivalClass() = default;
+
+        private:
+        nlohmann::json adroitly;
+        nlohmann::json bridehood;
+        nlohmann::json castoroides;
+        nlohmann::json czechoslovak;
+        nlohmann::json diagenesis;
+        nlohmann::json dihexahedron;
+        nlohmann::json dopester;
+        nlohmann::json eumerism;
+        nlohmann::json flyness;
+        nlohmann::json fouler;
+        nlohmann::json laudanosine;
+        nlohmann::json lingulidae;
+        nlohmann::json minutary;
+        nlohmann::json mitra;
+        nlohmann::json opisthorchiasis;
+        nlohmann::json pensively;
+        nlohmann::json pubigerous;
+        nlohmann::json rebellious;
+        nlohmann::json recodify;
+        nlohmann::json unpaced;
+
+        public:
+        const nlohmann::json & get_adroitly() const { return adroitly; }
+        nlohmann::json & get_mutable_adroitly() { return adroitly; }
+        void set_adroitly(const nlohmann::json & value) { this->adroitly = value; }
+
+        const nlohmann::json & get_bridehood() const { return bridehood; }
+        nlohmann::json & get_mutable_bridehood() { return bridehood; }
+        void set_bridehood(const nlohmann::json & value) { this->bridehood = value; }
+
+        const nlohmann::json & get_castoroides() const { return castoroides; }
+        nlohmann::json & get_mutable_castoroides() { return castoroides; }
+        void set_castoroides(const nlohmann::json & value) { this->castoroides = value; }
+
+        const nlohmann::json & get_czechoslovak() const { return czechoslovak; }
+        nlohmann::json & get_mutable_czechoslovak() { return czechoslovak; }
+        void set_czechoslovak(const nlohmann::json & value) { this->czechoslovak = value; }
+
+        const nlohmann::json & get_diagenesis() const { return diagenesis; }
+        nlohmann::json & get_mutable_diagenesis() { return diagenesis; }
+        void set_diagenesis(const nlohmann::json & value) { this->diagenesis = value; }
+
+        const nlohmann::json & get_dihexahedron() const { return dihexahedron; }
+        nlohmann::json & get_mutable_dihexahedron() { return dihexahedron; }
+        void set_dihexahedron(const nlohmann::json & value) { this->dihexahedron = value; }
+
+        const nlohmann::json & get_dopester() const { return dopester; }
+        nlohmann::json & get_mutable_dopester() { return dopester; }
+        void set_dopester(const nlohmann::json & value) { this->dopester = value; }
+
+        const nlohmann::json & get_eumerism() const { return eumerism; }
+        nlohmann::json & get_mutable_eumerism() { return eumerism; }
+        void set_eumerism(const nlohmann::json & value) { this->eumerism = value; }
+
+        const nlohmann::json & get_flyness() const { return flyness; }
+        nlohmann::json & get_mutable_flyness() { return flyness; }
+        void set_flyness(const nlohmann::json & value) { this->flyness = value; }
+
+        const nlohmann::json & get_fouler() const { return fouler; }
+        nlohmann::json & get_mutable_fouler() { return fouler; }
+        void set_fouler(const nlohmann::json & value) { this->fouler = value; }
+
+        const nlohmann::json & get_laudanosine() const { return laudanosine; }
+        nlohmann::json & get_mutable_laudanosine() { return laudanosine; }
+        void set_laudanosine(const nlohmann::json & value) { this->laudanosine = value; }
+
+        const nlohmann::json & get_lingulidae() const { return lingulidae; }
+        nlohmann::json & get_mutable_lingulidae() { return lingulidae; }
+        void set_lingulidae(const nlohmann::json & value) { this->lingulidae = value; }
+
+        const nlohmann::json & get_minutary() const { return minutary; }
+        nlohmann::json & get_mutable_minutary() { return minutary; }
+        void set_minutary(const nlohmann::json & value) { this->minutary = value; }
+
+        const nlohmann::json & get_mitra() const { return mitra; }
+        nlohmann::json & get_mutable_mitra() { return mitra; }
+        void set_mitra(const nlohmann::json & value) { this->mitra = value; }
+
+        const nlohmann::json & get_opisthorchiasis() const { return opisthorchiasis; }
+        nlohmann::json & get_mutable_opisthorchiasis() { return opisthorchiasis; }
+        void set_opisthorchiasis(const nlohmann::json & value) { this->opisthorchiasis = value; }
+
+        const nlohmann::json & get_pensively() const { return pensively; }
+        nlohmann::json & get_mutable_pensively() { return pensively; }
+        void set_pensively(const nlohmann::json & value) { this->pensively = value; }
+
+        const nlohmann::json & get_pubigerous() const { return pubigerous; }
+        nlohmann::json & get_mutable_pubigerous() { return pubigerous; }
+        void set_pubigerous(const nlohmann::json & value) { this->pubigerous = value; }
+
+        const nlohmann::json & get_rebellious() const { return rebellious; }
+        nlohmann::json & get_mutable_rebellious() { return rebellious; }
+        void set_rebellious(const nlohmann::json & value) { this->rebellious = value; }
+
+        const nlohmann::json & get_recodify() const { return recodify; }
+        nlohmann::json & get_mutable_recodify() { return recodify; }
+        void set_recodify(const nlohmann::json & value) { this->recodify = value; }
+
+        const nlohmann::json & get_unpaced() const { return unpaced; }
+        nlohmann::json & get_mutable_unpaced() { return unpaced; }
+        void set_unpaced(const nlohmann::json & value) { this->unpaced = value; }
+    };
+
+    using OutrivalElement = std::optional<std::variant<OutrivalClass, double>>;
+
+    using Paleographically = std::variant<double, std::map<std::string, std::optional<int64_t>>>;
+
+    using Pamphletwise = std::variant<int64_t, std::map<std::string, int64_t>, std::string>;
+
+    using Pediatric = std::optional<std::variant<bool, double>>;
+
+    class PiaculumClass {
+        public:
+        PiaculumClass() = default;
+        virtual ~PiaculumClass() = default;
+
+        private:
+        std::optional<int64_t> alada;
+        std::optional<int64_t> amphistomous;
+        std::optional<int64_t> boysenberry;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> decardinalize;
+        std::optional<int64_t> discouragement;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> doitrified;
+        std::optional<int64_t> hexaspermous;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> insinking;
+        std::optional<int64_t> loathfulness;
+        std::optional<int64_t> miasmatical;
+        std::optional<int64_t> neurofibril;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> phonendoscope;
+        std::optional<int64_t> pilferment;
+        std::optional<int64_t> predismissory;
+        std::optional<int64_t> preinscription;
+        std::optional<int64_t> quotative;
+        std::optional<int64_t> sienna;
+        std::optional<int64_t> thorax;
+        std::optional<int64_t> yachting;
+        std::optional<int64_t> zipper;
+
+        public:
+        const std::optional<int64_t> & get_alada() const { return alada; }
+        std::optional<int64_t> & get_mutable_alada() { return alada; }
+        void set_alada(const std::optional<int64_t> & value) { this->alada = value; }
+
+        const std::optional<int64_t> & get_amphistomous() const { return amphistomous; }
+        std::optional<int64_t> & get_mutable_amphistomous() { return amphistomous; }
+        void set_amphistomous(const std::optional<int64_t> & value) { this->amphistomous = value; }
+
+        const std::optional<int64_t> & get_boysenberry() const { return boysenberry; }
+        std::optional<int64_t> & get_mutable_boysenberry() { return boysenberry; }
+        void set_boysenberry(const std::optional<int64_t> & value) { this->boysenberry = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_decardinalize() const { return decardinalize; }
+        std::optional<int64_t> & get_mutable_decardinalize() { return decardinalize; }
+        void set_decardinalize(const std::optional<int64_t> & value) { this->decardinalize = value; }
+
+        const std::optional<int64_t> & get_discouragement() const { return discouragement; }
+        std::optional<int64_t> & get_mutable_discouragement() { return discouragement; }
+        void set_discouragement(const std::optional<int64_t> & value) { this->discouragement = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_doitrified() const { return doitrified; }
+        std::optional<int64_t> & get_mutable_doitrified() { return doitrified; }
+        void set_doitrified(const std::optional<int64_t> & value) { this->doitrified = value; }
+
+        const std::optional<int64_t> & get_hexaspermous() const { return hexaspermous; }
+        std::optional<int64_t> & get_mutable_hexaspermous() { return hexaspermous; }
+        void set_hexaspermous(const std::optional<int64_t> & value) { this->hexaspermous = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_insinking() const { return insinking; }
+        std::optional<int64_t> & get_mutable_insinking() { return insinking; }
+        void set_insinking(const std::optional<int64_t> & value) { this->insinking = value; }
+
+        const std::optional<int64_t> & get_loathfulness() const { return loathfulness; }
+        std::optional<int64_t> & get_mutable_loathfulness() { return loathfulness; }
+        void set_loathfulness(const std::optional<int64_t> & value) { this->loathfulness = value; }
+
+        const std::optional<int64_t> & get_miasmatical() const { return miasmatical; }
+        std::optional<int64_t> & get_mutable_miasmatical() { return miasmatical; }
+        void set_miasmatical(const std::optional<int64_t> & value) { this->miasmatical = value; }
+
+        const std::optional<int64_t> & get_neurofibril() const { return neurofibril; }
+        std::optional<int64_t> & get_mutable_neurofibril() { return neurofibril; }
+        void set_neurofibril(const std::optional<int64_t> & value) { this->neurofibril = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_phonendoscope() const { return phonendoscope; }
+        std::optional<int64_t> & get_mutable_phonendoscope() { return phonendoscope; }
+        void set_phonendoscope(const std::optional<int64_t> & value) { this->phonendoscope = value; }
+
+        const std::optional<int64_t> & get_pilferment() const { return pilferment; }
+        std::optional<int64_t> & get_mutable_pilferment() { return pilferment; }
+        void set_pilferment(const std::optional<int64_t> & value) { this->pilferment = value; }
+
+        const std::optional<int64_t> & get_predismissory() const { return predismissory; }
+        std::optional<int64_t> & get_mutable_predismissory() { return predismissory; }
+        void set_predismissory(const std::optional<int64_t> & value) { this->predismissory = value; }
+
+        const std::optional<int64_t> & get_preinscription() const { return preinscription; }
+        std::optional<int64_t> & get_mutable_preinscription() { return preinscription; }
+        void set_preinscription(const std::optional<int64_t> & value) { this->preinscription = value; }
+
+        const std::optional<int64_t> & get_quotative() const { return quotative; }
+        std::optional<int64_t> & get_mutable_quotative() { return quotative; }
+        void set_quotative(const std::optional<int64_t> & value) { this->quotative = value; }
+
+        const std::optional<int64_t> & get_sienna() const { return sienna; }
+        std::optional<int64_t> & get_mutable_sienna() { return sienna; }
+        void set_sienna(const std::optional<int64_t> & value) { this->sienna = value; }
+
+        const std::optional<int64_t> & get_thorax() const { return thorax; }
+        std::optional<int64_t> & get_mutable_thorax() { return thorax; }
+        void set_thorax(const std::optional<int64_t> & value) { this->thorax = value; }
+
+        const std::optional<int64_t> & get_yachting() const { return yachting; }
+        std::optional<int64_t> & get_mutable_yachting() { return yachting; }
+        void set_yachting(const std::optional<int64_t> & value) { this->yachting = value; }
+
+        const std::optional<int64_t> & get_zipper() const { return zipper; }
+        std::optional<int64_t> & get_mutable_zipper() { return zipper; }
+        void set_zipper(const std::optional<int64_t> & value) { this->zipper = value; }
+    };
+
+    using PiaculumElement = std::variant<PiaculumClass, double>;
+
+    using Piccadilly = std::optional<std::variant<double, std::string>>;
+
+    using Piffler = std::variant<std::vector<nlohmann::json>, MonaziteClass>;
+
+    using Pithful = std::optional<std::variant<bool, int64_t>>;
+
+    using Placuntiti = std::variant<int64_t, std::map<std::string, int64_t>>;
+
+    using Plectopterous = std::variant<double, std::map<std::string, int64_t>>;
+
+    class Pneumocele {
+        public:
+        Pneumocele() = default;
+        virtual ~Pneumocele() = default;
+
+        private:
+        nlohmann::json carbonarism;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json cineolic;
+        nlohmann::json cobbly;
+        nlohmann::json conchyliferous;
+        nlohmann::json congregation;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enterotomy;
+        nlohmann::json entophytal;
+        nlohmann::json fewtrils;
+        nlohmann::json herem;
+        std::optional<bool> homocerc;
+        nlohmann::json koniga;
+        nlohmann::json meticulosity;
+        nlohmann::json micky;
+        nlohmann::json mismarriage;
+        nlohmann::json neurotrophic;
+        nlohmann::json nonbookish;
+        nlohmann::json persuasively;
+        nlohmann::json replaceable;
+        nlohmann::json silex;
+        nlohmann::json taillight;
+        nlohmann::json unjealous;
+        nlohmann::json visitorial;
+
+        public:
+        const nlohmann::json & get_carbonarism() const { return carbonarism; }
+        nlohmann::json & get_mutable_carbonarism() { return carbonarism; }
+        void set_carbonarism(const nlohmann::json & value) { this->carbonarism = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const nlohmann::json & get_cineolic() const { return cineolic; }
+        nlohmann::json & get_mutable_cineolic() { return cineolic; }
+        void set_cineolic(const nlohmann::json & value) { this->cineolic = value; }
+
+        const nlohmann::json & get_cobbly() const { return cobbly; }
+        nlohmann::json & get_mutable_cobbly() { return cobbly; }
+        void set_cobbly(const nlohmann::json & value) { this->cobbly = value; }
+
+        const nlohmann::json & get_conchyliferous() const { return conchyliferous; }
+        nlohmann::json & get_mutable_conchyliferous() { return conchyliferous; }
+        void set_conchyliferous(const nlohmann::json & value) { this->conchyliferous = value; }
+
+        const nlohmann::json & get_congregation() const { return congregation; }
+        nlohmann::json & get_mutable_congregation() { return congregation; }
+        void set_congregation(const nlohmann::json & value) { this->congregation = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_enterotomy() const { return enterotomy; }
+        nlohmann::json & get_mutable_enterotomy() { return enterotomy; }
+        void set_enterotomy(const nlohmann::json & value) { this->enterotomy = value; }
+
+        const nlohmann::json & get_entophytal() const { return entophytal; }
+        nlohmann::json & get_mutable_entophytal() { return entophytal; }
+        void set_entophytal(const nlohmann::json & value) { this->entophytal = value; }
+
+        const nlohmann::json & get_fewtrils() const { return fewtrils; }
+        nlohmann::json & get_mutable_fewtrils() { return fewtrils; }
+        void set_fewtrils(const nlohmann::json & value) { this->fewtrils = value; }
+
+        const nlohmann::json & get_herem() const { return herem; }
+        nlohmann::json & get_mutable_herem() { return herem; }
+        void set_herem(const nlohmann::json & value) { this->herem = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_koniga() const { return koniga; }
+        nlohmann::json & get_mutable_koniga() { return koniga; }
+        void set_koniga(const nlohmann::json & value) { this->koniga = value; }
+
+        const nlohmann::json & get_meticulosity() const { return meticulosity; }
+        nlohmann::json & get_mutable_meticulosity() { return meticulosity; }
+        void set_meticulosity(const nlohmann::json & value) { this->meticulosity = value; }
+
+        const nlohmann::json & get_micky() const { return micky; }
+        nlohmann::json & get_mutable_micky() { return micky; }
+        void set_micky(const nlohmann::json & value) { this->micky = value; }
+
+        const nlohmann::json & get_mismarriage() const { return mismarriage; }
+        nlohmann::json & get_mutable_mismarriage() { return mismarriage; }
+        void set_mismarriage(const nlohmann::json & value) { this->mismarriage = value; }
+
+        const nlohmann::json & get_neurotrophic() const { return neurotrophic; }
+        nlohmann::json & get_mutable_neurotrophic() { return neurotrophic; }
+        void set_neurotrophic(const nlohmann::json & value) { this->neurotrophic = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_persuasively() const { return persuasively; }
+        nlohmann::json & get_mutable_persuasively() { return persuasively; }
+        void set_persuasively(const nlohmann::json & value) { this->persuasively = value; }
+
+        const nlohmann::json & get_replaceable() const { return replaceable; }
+        nlohmann::json & get_mutable_replaceable() { return replaceable; }
+        void set_replaceable(const nlohmann::json & value) { this->replaceable = value; }
+
+        const nlohmann::json & get_silex() const { return silex; }
+        nlohmann::json & get_mutable_silex() { return silex; }
+        void set_silex(const nlohmann::json & value) { this->silex = value; }
+
+        const nlohmann::json & get_taillight() const { return taillight; }
+        nlohmann::json & get_mutable_taillight() { return taillight; }
+        void set_taillight(const nlohmann::json & value) { this->taillight = value; }
+
+        const nlohmann::json & get_unjealous() const { return unjealous; }
+        nlohmann::json & get_mutable_unjealous() { return unjealous; }
+        void set_unjealous(const nlohmann::json & value) { this->unjealous = value; }
+
+        const nlohmann::json & get_visitorial() const { return visitorial; }
+        nlohmann::json & get_mutable_visitorial() { return visitorial; }
+        void set_visitorial(const nlohmann::json & value) { this->visitorial = value; }
+    };
+
+    using Poliorcetic = std::variant<bool, MonaziteClass>;
+
+    using Poormaster = std::optional<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>;
+
+    class PotwhiskyClass {
+        public:
+        PotwhiskyClass() = default;
+        virtual ~PotwhiskyClass() = default;
+
+        private:
+        nlohmann::json arciform;
+        nlohmann::json cresolin;
+        nlohmann::json disheartener;
+        nlohmann::json disproportionable;
+        nlohmann::json euchorda;
+        nlohmann::json ferryway;
+        nlohmann::json filamentiferous;
+        nlohmann::json flemish;
+        nlohmann::json forgainst;
+        nlohmann::json grainering;
+        nlohmann::json irrevoluble;
+        nlohmann::json kindredship;
+        nlohmann::json pinguitudinous;
+        nlohmann::json simpletonic;
+        nlohmann::json singsong;
+        nlohmann::json submergement;
+        nlohmann::json supraoesophagal;
+        nlohmann::json thrashel;
+        nlohmann::json tyremesis;
+        nlohmann::json yoruba;
+
+        public:
+        const nlohmann::json & get_arciform() const { return arciform; }
+        nlohmann::json & get_mutable_arciform() { return arciform; }
+        void set_arciform(const nlohmann::json & value) { this->arciform = value; }
+
+        const nlohmann::json & get_cresolin() const { return cresolin; }
+        nlohmann::json & get_mutable_cresolin() { return cresolin; }
+        void set_cresolin(const nlohmann::json & value) { this->cresolin = value; }
+
+        const nlohmann::json & get_disheartener() const { return disheartener; }
+        nlohmann::json & get_mutable_disheartener() { return disheartener; }
+        void set_disheartener(const nlohmann::json & value) { this->disheartener = value; }
+
+        const nlohmann::json & get_disproportionable() const { return disproportionable; }
+        nlohmann::json & get_mutable_disproportionable() { return disproportionable; }
+        void set_disproportionable(const nlohmann::json & value) { this->disproportionable = value; }
+
+        const nlohmann::json & get_euchorda() const { return euchorda; }
+        nlohmann::json & get_mutable_euchorda() { return euchorda; }
+        void set_euchorda(const nlohmann::json & value) { this->euchorda = value; }
+
+        const nlohmann::json & get_ferryway() const { return ferryway; }
+        nlohmann::json & get_mutable_ferryway() { return ferryway; }
+        void set_ferryway(const nlohmann::json & value) { this->ferryway = value; }
+
+        const nlohmann::json & get_filamentiferous() const { return filamentiferous; }
+        nlohmann::json & get_mutable_filamentiferous() { return filamentiferous; }
+        void set_filamentiferous(const nlohmann::json & value) { this->filamentiferous = value; }
+
+        const nlohmann::json & get_flemish() const { return flemish; }
+        nlohmann::json & get_mutable_flemish() { return flemish; }
+        void set_flemish(const nlohmann::json & value) { this->flemish = value; }
+
+        const nlohmann::json & get_forgainst() const { return forgainst; }
+        nlohmann::json & get_mutable_forgainst() { return forgainst; }
+        void set_forgainst(const nlohmann::json & value) { this->forgainst = value; }
+
+        const nlohmann::json & get_grainering() const { return grainering; }
+        nlohmann::json & get_mutable_grainering() { return grainering; }
+        void set_grainering(const nlohmann::json & value) { this->grainering = value; }
+
+        const nlohmann::json & get_irrevoluble() const { return irrevoluble; }
+        nlohmann::json & get_mutable_irrevoluble() { return irrevoluble; }
+        void set_irrevoluble(const nlohmann::json & value) { this->irrevoluble = value; }
+
+        const nlohmann::json & get_kindredship() const { return kindredship; }
+        nlohmann::json & get_mutable_kindredship() { return kindredship; }
+        void set_kindredship(const nlohmann::json & value) { this->kindredship = value; }
+
+        const nlohmann::json & get_pinguitudinous() const { return pinguitudinous; }
+        nlohmann::json & get_mutable_pinguitudinous() { return pinguitudinous; }
+        void set_pinguitudinous(const nlohmann::json & value) { this->pinguitudinous = value; }
+
+        const nlohmann::json & get_simpletonic() const { return simpletonic; }
+        nlohmann::json & get_mutable_simpletonic() { return simpletonic; }
+        void set_simpletonic(const nlohmann::json & value) { this->simpletonic = value; }
+
+        const nlohmann::json & get_singsong() const { return singsong; }
+        nlohmann::json & get_mutable_singsong() { return singsong; }
+        void set_singsong(const nlohmann::json & value) { this->singsong = value; }
+
+        const nlohmann::json & get_submergement() const { return submergement; }
+        nlohmann::json & get_mutable_submergement() { return submergement; }
+        void set_submergement(const nlohmann::json & value) { this->submergement = value; }
+
+        const nlohmann::json & get_supraoesophagal() const { return supraoesophagal; }
+        nlohmann::json & get_mutable_supraoesophagal() { return supraoesophagal; }
+        void set_supraoesophagal(const nlohmann::json & value) { this->supraoesophagal = value; }
+
+        const nlohmann::json & get_thrashel() const { return thrashel; }
+        nlohmann::json & get_mutable_thrashel() { return thrashel; }
+        void set_thrashel(const nlohmann::json & value) { this->thrashel = value; }
+
+        const nlohmann::json & get_tyremesis() const { return tyremesis; }
+        nlohmann::json & get_mutable_tyremesis() { return tyremesis; }
+        void set_tyremesis(const nlohmann::json & value) { this->tyremesis = value; }
+
+        const nlohmann::json & get_yoruba() const { return yoruba; }
+        nlohmann::json & get_mutable_yoruba() { return yoruba; }
+        void set_yoruba(const nlohmann::json & value) { this->yoruba = value; }
+    };
+
+    using PotwhiskyElement = std::optional<std::variant<PotwhiskyClass, int64_t>>;
+
+    using Practicalizer = std::variant<std::vector<nlohmann::json>, MonaziteClass, std::string>;
+
+    class PrefreshmanClass {
+        public:
+        PrefreshmanClass() = default;
+        virtual ~PrefreshmanClass() = default;
+
+        private:
+        nlohmann::json azorubine;
+        nlohmann::json choroiditis;
+        nlohmann::json coagulatory;
+        nlohmann::json cyclorama;
+        nlohmann::json dolphus;
+        nlohmann::json duckhearted;
+        nlohmann::json ficus;
+        nlohmann::json gemaric;
+        nlohmann::json jugation;
+        nlohmann::json myoliposis;
+        nlohmann::json nonnomination;
+        nlohmann::json palay;
+        nlohmann::json pentactinal;
+        nlohmann::json phaet;
+        nlohmann::json piquant;
+        nlohmann::json registration;
+        nlohmann::json remancipation;
+        nlohmann::json scutatiform;
+        nlohmann::json theodolite;
+        nlohmann::json underward;
+
+        public:
+        const nlohmann::json & get_azorubine() const { return azorubine; }
+        nlohmann::json & get_mutable_azorubine() { return azorubine; }
+        void set_azorubine(const nlohmann::json & value) { this->azorubine = value; }
+
+        const nlohmann::json & get_choroiditis() const { return choroiditis; }
+        nlohmann::json & get_mutable_choroiditis() { return choroiditis; }
+        void set_choroiditis(const nlohmann::json & value) { this->choroiditis = value; }
+
+        const nlohmann::json & get_coagulatory() const { return coagulatory; }
+        nlohmann::json & get_mutable_coagulatory() { return coagulatory; }
+        void set_coagulatory(const nlohmann::json & value) { this->coagulatory = value; }
+
+        const nlohmann::json & get_cyclorama() const { return cyclorama; }
+        nlohmann::json & get_mutable_cyclorama() { return cyclorama; }
+        void set_cyclorama(const nlohmann::json & value) { this->cyclorama = value; }
+
+        const nlohmann::json & get_dolphus() const { return dolphus; }
+        nlohmann::json & get_mutable_dolphus() { return dolphus; }
+        void set_dolphus(const nlohmann::json & value) { this->dolphus = value; }
+
+        const nlohmann::json & get_duckhearted() const { return duckhearted; }
+        nlohmann::json & get_mutable_duckhearted() { return duckhearted; }
+        void set_duckhearted(const nlohmann::json & value) { this->duckhearted = value; }
+
+        const nlohmann::json & get_ficus() const { return ficus; }
+        nlohmann::json & get_mutable_ficus() { return ficus; }
+        void set_ficus(const nlohmann::json & value) { this->ficus = value; }
+
+        const nlohmann::json & get_gemaric() const { return gemaric; }
+        nlohmann::json & get_mutable_gemaric() { return gemaric; }
+        void set_gemaric(const nlohmann::json & value) { this->gemaric = value; }
+
+        const nlohmann::json & get_jugation() const { return jugation; }
+        nlohmann::json & get_mutable_jugation() { return jugation; }
+        void set_jugation(const nlohmann::json & value) { this->jugation = value; }
+
+        const nlohmann::json & get_myoliposis() const { return myoliposis; }
+        nlohmann::json & get_mutable_myoliposis() { return myoliposis; }
+        void set_myoliposis(const nlohmann::json & value) { this->myoliposis = value; }
+
+        const nlohmann::json & get_nonnomination() const { return nonnomination; }
+        nlohmann::json & get_mutable_nonnomination() { return nonnomination; }
+        void set_nonnomination(const nlohmann::json & value) { this->nonnomination = value; }
+
+        const nlohmann::json & get_palay() const { return palay; }
+        nlohmann::json & get_mutable_palay() { return palay; }
+        void set_palay(const nlohmann::json & value) { this->palay = value; }
+
+        const nlohmann::json & get_pentactinal() const { return pentactinal; }
+        nlohmann::json & get_mutable_pentactinal() { return pentactinal; }
+        void set_pentactinal(const nlohmann::json & value) { this->pentactinal = value; }
+
+        const nlohmann::json & get_phaet() const { return phaet; }
+        nlohmann::json & get_mutable_phaet() { return phaet; }
+        void set_phaet(const nlohmann::json & value) { this->phaet = value; }
+
+        const nlohmann::json & get_piquant() const { return piquant; }
+        nlohmann::json & get_mutable_piquant() { return piquant; }
+        void set_piquant(const nlohmann::json & value) { this->piquant = value; }
+
+        const nlohmann::json & get_registration() const { return registration; }
+        nlohmann::json & get_mutable_registration() { return registration; }
+        void set_registration(const nlohmann::json & value) { this->registration = value; }
+
+        const nlohmann::json & get_remancipation() const { return remancipation; }
+        nlohmann::json & get_mutable_remancipation() { return remancipation; }
+        void set_remancipation(const nlohmann::json & value) { this->remancipation = value; }
+
+        const nlohmann::json & get_scutatiform() const { return scutatiform; }
+        nlohmann::json & get_mutable_scutatiform() { return scutatiform; }
+        void set_scutatiform(const nlohmann::json & value) { this->scutatiform = value; }
+
+        const nlohmann::json & get_theodolite() const { return theodolite; }
+        nlohmann::json & get_mutable_theodolite() { return theodolite; }
+        void set_theodolite(const nlohmann::json & value) { this->theodolite = value; }
+
+        const nlohmann::json & get_underward() const { return underward; }
+        nlohmann::json & get_mutable_underward() { return underward; }
+        void set_underward(const nlohmann::json & value) { this->underward = value; }
+    };
+
+    using PrefreshmanElement = std::variant<std::vector<nlohmann::json>, PrefreshmanClass, std::string>;
+
+    using Prehensility = std::variant<std::vector<nlohmann::json>, bool, MonaziteClass>;
+
+    using Prevoidance = std::variant<std::vector<int64_t>, MonaziteClass, int64_t>;
+
+    using Protext = std::variant<std::vector<int64_t>, bool, MonaziteClass>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::vector<JurorElement> juror;
+        std::vector<Kongoni> kongoni;
+        std::vector<LadronismElement> ladronism;
+        std::vector<LandlubberlyElement> landlubberly;
+        std::vector<Listener> listener;
+        std::vector<LupusElement> lupus;
+        std::vector<Maslin> maslin;
+        std::vector<MonaziteElement> monazite;
+        std::vector<Monoliteral> monoliteral;
+        std::vector<MonotheisticallyElement> monotheistically;
+        std::vector<Montage> montage;
+        std::vector<Moralness> moralness;
+        std::vector<std::optional<MonaziteClass>> mowra;
+        std::vector<Mulishly> mulishly;
+        std::vector<Myoscope> myoscope;
+        std::vector<std::optional<std::vector<std::optional<int64_t>>>> nach;
+        std::vector<Neuromastic> neuromastic;
+        std::vector<Noncontributing> noncontributing;
+        std::vector<Nonnervous> nonnervous;
+        std::vector<Nonvaluation> nonvaluation;
+        std::vector<OccupationalistElement> occupationalist;
+        std::vector<OutrivalElement> outrival;
+        std::vector<Paleographically> paleographically;
+        std::vector<Pamphletwise> pamphletwise;
+        std::vector<Pediatric> pediatrics;
+        std::vector<bool> perceptive;
+        std::vector<PiaculumElement> piaculum;
+        std::vector<Piccadilly> piccadilly;
+        std::vector<Piffler> piffler;
+        std::vector<Pithful> pithful;
+        std::vector<Placuntiti> placuntitis;
+        std::vector<Plectopterous> plectopterous;
+        std::vector<std::optional<Pneumocele>> pneumocele;
+        std::vector<Poliorcetic> poliorcetic;
+        std::vector<Poormaster> poormaster;
+        std::vector<PotwhiskyElement> potwhisky;
+        std::vector<Practicalizer> practicalizer;
+        std::vector<PrefreshmanElement> prefreshman;
+        std::vector<Prehensility> prehensility;
+        std::vector<Prevoidance> prevoidance;
+        std::vector<std::map<std::string, std::optional<int64_t>>> probant;
+        std::vector<Protext> protext;
+
+        public:
+        const std::vector<JurorElement> & get_juror() const { return juror; }
+        std::vector<JurorElement> & get_mutable_juror() { return juror; }
+        void set_juror(const std::vector<JurorElement> & value) { this->juror = value; }
+
+        const std::vector<Kongoni> & get_kongoni() const { return kongoni; }
+        std::vector<Kongoni> & get_mutable_kongoni() { return kongoni; }
+        void set_kongoni(const std::vector<Kongoni> & value) { this->kongoni = value; }
+
+        const std::vector<LadronismElement> & get_ladronism() const { return ladronism; }
+        std::vector<LadronismElement> & get_mutable_ladronism() { return ladronism; }
+        void set_ladronism(const std::vector<LadronismElement> & value) { this->ladronism = value; }
+
+        const std::vector<LandlubberlyElement> & get_landlubberly() const { return landlubberly; }
+        std::vector<LandlubberlyElement> & get_mutable_landlubberly() { return landlubberly; }
+        void set_landlubberly(const std::vector<LandlubberlyElement> & value) { this->landlubberly = value; }
+
+        const std::vector<Listener> & get_listener() const { return listener; }
+        std::vector<Listener> & get_mutable_listener() { return listener; }
+        void set_listener(const std::vector<Listener> & value) { this->listener = value; }
+
+        const std::vector<LupusElement> & get_lupus() const { return lupus; }
+        std::vector<LupusElement> & get_mutable_lupus() { return lupus; }
+        void set_lupus(const std::vector<LupusElement> & value) { this->lupus = value; }
+
+        const std::vector<Maslin> & get_maslin() const { return maslin; }
+        std::vector<Maslin> & get_mutable_maslin() { return maslin; }
+        void set_maslin(const std::vector<Maslin> & value) { this->maslin = value; }
+
+        const std::vector<MonaziteElement> & get_monazite() const { return monazite; }
+        std::vector<MonaziteElement> & get_mutable_monazite() { return monazite; }
+        void set_monazite(const std::vector<MonaziteElement> & value) { this->monazite = value; }
+
+        const std::vector<Monoliteral> & get_monoliteral() const { return monoliteral; }
+        std::vector<Monoliteral> & get_mutable_monoliteral() { return monoliteral; }
+        void set_monoliteral(const std::vector<Monoliteral> & value) { this->monoliteral = value; }
+
+        const std::vector<MonotheisticallyElement> & get_monotheistically() const { return monotheistically; }
+        std::vector<MonotheisticallyElement> & get_mutable_monotheistically() { return monotheistically; }
+        void set_monotheistically(const std::vector<MonotheisticallyElement> & value) { this->monotheistically = value; }
+
+        const std::vector<Montage> & get_montage() const { return montage; }
+        std::vector<Montage> & get_mutable_montage() { return montage; }
+        void set_montage(const std::vector<Montage> & value) { this->montage = value; }
+
+        const std::vector<Moralness> & get_moralness() const { return moralness; }
+        std::vector<Moralness> & get_mutable_moralness() { return moralness; }
+        void set_moralness(const std::vector<Moralness> & value) { this->moralness = value; }
+
+        const std::vector<std::optional<MonaziteClass>> & get_mowra() const { return mowra; }
+        std::vector<std::optional<MonaziteClass>> & get_mutable_mowra() { return mowra; }
+        void set_mowra(const std::vector<std::optional<MonaziteClass>> & value) { this->mowra = value; }
+
+        const std::vector<Mulishly> & get_mulishly() const { return mulishly; }
+        std::vector<Mulishly> & get_mutable_mulishly() { return mulishly; }
+        void set_mulishly(const std::vector<Mulishly> & value) { this->mulishly = value; }
+
+        const std::vector<Myoscope> & get_myoscope() const { return myoscope; }
+        std::vector<Myoscope> & get_mutable_myoscope() { return myoscope; }
+        void set_myoscope(const std::vector<Myoscope> & value) { this->myoscope = value; }
+
+        const std::vector<std::optional<std::vector<std::optional<int64_t>>>> & get_nach() const { return nach; }
+        std::vector<std::optional<std::vector<std::optional<int64_t>>>> & get_mutable_nach() { return nach; }
+        void set_nach(const std::vector<std::optional<std::vector<std::optional<int64_t>>>> & value) { this->nach = value; }
+
+        const std::vector<Neuromastic> & get_neuromastic() const { return neuromastic; }
+        std::vector<Neuromastic> & get_mutable_neuromastic() { return neuromastic; }
+        void set_neuromastic(const std::vector<Neuromastic> & value) { this->neuromastic = value; }
+
+        const std::vector<Noncontributing> & get_noncontributing() const { return noncontributing; }
+        std::vector<Noncontributing> & get_mutable_noncontributing() { return noncontributing; }
+        void set_noncontributing(const std::vector<Noncontributing> & value) { this->noncontributing = value; }
+
+        const std::vector<Nonnervous> & get_nonnervous() const { return nonnervous; }
+        std::vector<Nonnervous> & get_mutable_nonnervous() { return nonnervous; }
+        void set_nonnervous(const std::vector<Nonnervous> & value) { this->nonnervous = value; }
+
+        const std::vector<Nonvaluation> & get_nonvaluation() const { return nonvaluation; }
+        std::vector<Nonvaluation> & get_mutable_nonvaluation() { return nonvaluation; }
+        void set_nonvaluation(const std::vector<Nonvaluation> & value) { this->nonvaluation = value; }
+
+        const std::vector<OccupationalistElement> & get_occupationalist() const { return occupationalist; }
+        std::vector<OccupationalistElement> & get_mutable_occupationalist() { return occupationalist; }
+        void set_occupationalist(const std::vector<OccupationalistElement> & value) { this->occupationalist = value; }
+
+        const std::vector<OutrivalElement> & get_outrival() const { return outrival; }
+        std::vector<OutrivalElement> & get_mutable_outrival() { return outrival; }
+        void set_outrival(const std::vector<OutrivalElement> & value) { this->outrival = value; }
+
+        const std::vector<Paleographically> & get_paleographically() const { return paleographically; }
+        std::vector<Paleographically> & get_mutable_paleographically() { return paleographically; }
+        void set_paleographically(const std::vector<Paleographically> & value) { this->paleographically = value; }
+
+        const std::vector<Pamphletwise> & get_pamphletwise() const { return pamphletwise; }
+        std::vector<Pamphletwise> & get_mutable_pamphletwise() { return pamphletwise; }
+        void set_pamphletwise(const std::vector<Pamphletwise> & value) { this->pamphletwise = value; }
+
+        const std::vector<Pediatric> & get_pediatrics() const { return pediatrics; }
+        std::vector<Pediatric> & get_mutable_pediatrics() { return pediatrics; }
+        void set_pediatrics(const std::vector<Pediatric> & value) { this->pediatrics = value; }
+
+        const std::vector<bool> & get_perceptive() const { return perceptive; }
+        std::vector<bool> & get_mutable_perceptive() { return perceptive; }
+        void set_perceptive(const std::vector<bool> & value) { this->perceptive = value; }
+
+        const std::vector<PiaculumElement> & get_piaculum() const { return piaculum; }
+        std::vector<PiaculumElement> & get_mutable_piaculum() { return piaculum; }
+        void set_piaculum(const std::vector<PiaculumElement> & value) { this->piaculum = value; }
+
+        const std::vector<Piccadilly> & get_piccadilly() const { return piccadilly; }
+        std::vector<Piccadilly> & get_mutable_piccadilly() { return piccadilly; }
+        void set_piccadilly(const std::vector<Piccadilly> & value) { this->piccadilly = value; }
+
+        const std::vector<Piffler> & get_piffler() const { return piffler; }
+        std::vector<Piffler> & get_mutable_piffler() { return piffler; }
+        void set_piffler(const std::vector<Piffler> & value) { this->piffler = value; }
+
+        const std::vector<Pithful> & get_pithful() const { return pithful; }
+        std::vector<Pithful> & get_mutable_pithful() { return pithful; }
+        void set_pithful(const std::vector<Pithful> & value) { this->pithful = value; }
+
+        const std::vector<Placuntiti> & get_placuntitis() const { return placuntitis; }
+        std::vector<Placuntiti> & get_mutable_placuntitis() { return placuntitis; }
+        void set_placuntitis(const std::vector<Placuntiti> & value) { this->placuntitis = value; }
+
+        const std::vector<Plectopterous> & get_plectopterous() const { return plectopterous; }
+        std::vector<Plectopterous> & get_mutable_plectopterous() { return plectopterous; }
+        void set_plectopterous(const std::vector<Plectopterous> & value) { this->plectopterous = value; }
+
+        const std::vector<std::optional<Pneumocele>> & get_pneumocele() const { return pneumocele; }
+        std::vector<std::optional<Pneumocele>> & get_mutable_pneumocele() { return pneumocele; }
+        void set_pneumocele(const std::vector<std::optional<Pneumocele>> & value) { this->pneumocele = value; }
+
+        const std::vector<Poliorcetic> & get_poliorcetic() const { return poliorcetic; }
+        std::vector<Poliorcetic> & get_mutable_poliorcetic() { return poliorcetic; }
+        void set_poliorcetic(const std::vector<Poliorcetic> & value) { this->poliorcetic = value; }
+
+        const std::vector<Poormaster> & get_poormaster() const { return poormaster; }
+        std::vector<Poormaster> & get_mutable_poormaster() { return poormaster; }
+        void set_poormaster(const std::vector<Poormaster> & value) { this->poormaster = value; }
+
+        const std::vector<PotwhiskyElement> & get_potwhisky() const { return potwhisky; }
+        std::vector<PotwhiskyElement> & get_mutable_potwhisky() { return potwhisky; }
+        void set_potwhisky(const std::vector<PotwhiskyElement> & value) { this->potwhisky = value; }
+
+        const std::vector<Practicalizer> & get_practicalizer() const { return practicalizer; }
+        std::vector<Practicalizer> & get_mutable_practicalizer() { return practicalizer; }
+        void set_practicalizer(const std::vector<Practicalizer> & value) { this->practicalizer = value; }
+
+        const std::vector<PrefreshmanElement> & get_prefreshman() const { return prefreshman; }
+        std::vector<PrefreshmanElement> & get_mutable_prefreshman() { return prefreshman; }
+        void set_prefreshman(const std::vector<PrefreshmanElement> & value) { this->prefreshman = value; }
+
+        const std::vector<Prehensility> & get_prehensility() const { return prehensility; }
+        std::vector<Prehensility> & get_mutable_prehensility() { return prehensility; }
+        void set_prehensility(const std::vector<Prehensility> & value) { this->prehensility = value; }
+
+        const std::vector<Prevoidance> & get_prevoidance() const { return prevoidance; }
+        std::vector<Prevoidance> & get_mutable_prevoidance() { return prevoidance; }
+        void set_prevoidance(const std::vector<Prevoidance> & value) { this->prevoidance = value; }
+
+        const std::vector<std::map<std::string, std::optional<int64_t>>> & get_probant() const { return probant; }
+        std::vector<std::map<std::string, std::optional<int64_t>>> & get_mutable_probant() { return probant; }
+        void set_probant(const std::vector<std::map<std::string, std::optional<int64_t>>> & value) { this->probant = value; }
+
+        const std::vector<Protext> & get_protext() const { return protext; }
+        std::vector<Protext> & get_mutable_protext() { return protext; }
+        void set_protext(const std::vector<Protext> & value) { this->protext = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, JurorClass & x);
+void to_json(json & j, const JurorClass & x);
+
+void from_json(const json & j, LadronismClass & x);
+void to_json(json & j, const LadronismClass & x);
+
+void from_json(const json & j, LandlubberlyClass & x);
+void to_json(json & j, const LandlubberlyClass & x);
+
+void from_json(const json & j, LupusClass & x);
+void to_json(json & j, const LupusClass & x);
+
+void from_json(const json & j, Maslin & x);
+void to_json(json & j, const Maslin & x);
+
+void from_json(const json & j, MonaziteClass & x);
+void to_json(json & j, const MonaziteClass & x);
+
+void from_json(const json & j, MonotheisticallyClass & x);
+void to_json(json & j, const MonotheisticallyClass & x);
+
+void from_json(const json & j, Noncontributing & x);
+void to_json(json & j, const Noncontributing & x);
+
+void from_json(const json & j, OccupationalistClass & x);
+void to_json(json & j, const OccupationalistClass & x);
+
+void from_json(const json & j, OutrivalClass & x);
+void to_json(json & j, const OutrivalClass & x);
+
+void from_json(const json & j, PiaculumClass & x);
+void to_json(json & j, const PiaculumClass & x);
+
+void from_json(const json & j, Pneumocele & x);
+void to_json(json & j, const Pneumocele & x);
+
+void from_json(const json & j, PotwhiskyClass & x);
+void to_json(json & j, const PotwhiskyClass & x);
+
+void from_json(const json & j, PrefreshmanClass & x);
+void to_json(json & j, const PrefreshmanClass & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<bool, quicktype::JurorClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::JurorClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::JurorClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::LadronismClass, double, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::LadronismClass, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::LupusClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::LupusClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::LupusClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::MonaziteClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::MonaziteClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::MonaziteClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t>> {
+    static void from_json(const json & j, std::variant<bool, int64_t> & x);
+    static void to_json(json & j, const std::variant<bool, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::OccupationalistClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::OutrivalClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::OutrivalClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::OutrivalClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, std::optional<int64_t>>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(const json & j, std::variant<bool, double> & x);
+    static void to_json(json & j, const std::variant<bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PiaculumClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::PiaculumClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::PiaculumClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::string>> {
+    static void from_json(const json & j, std::variant<double, std::string> & x);
+    static void to_json(json & j, const std::variant<double, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::MonaziteClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::PotwhiskyClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::PotwhiskyClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, JurorClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_adipsy(get_untyped(j, "adipsy"));
+        x.set_auxiliator(get_untyped(j, "auxiliator"));
+        x.set_benda(get_untyped(j, "benda"));
+        x.set_benjamin(get_untyped(j, "benjamin"));
+        x.set_brandling(get_untyped(j, "brandling"));
+        x.set_epicurishly(get_untyped(j, "epicurishly"));
+        x.set_eremochaetous(get_untyped(j, "eremochaetous"));
+        x.set_marten(get_untyped(j, "marten"));
+        x.set_monocline(get_untyped(j, "monocline"));
+        x.set_olea(get_untyped(j, "Olea"));
+        x.set_palgat(get_untyped(j, "palgat"));
+        x.set_pennyworth(get_untyped(j, "pennyworth"));
+        x.set_pioury(get_untyped(j, "pioury"));
+        x.set_pragmatistic(get_untyped(j, "pragmatistic"));
+        x.set_stylelessness(get_untyped(j, "stylelessness"));
+        x.set_systematical(get_untyped(j, "systematical"));
+        x.set_thready(get_untyped(j, "thready"));
+        x.set_uncontemporary(get_untyped(j, "uncontemporary"));
+        x.set_uncouched(get_untyped(j, "uncouched"));
+        x.set_uninhabitedness(get_untyped(j, "uninhabitedness"));
+    }
+
+    inline void to_json(json & j, const JurorClass & x) {
+        j = json::object();
+        j["adipsy"] = x.get_adipsy();
+        j["auxiliator"] = x.get_auxiliator();
+        j["benda"] = x.get_benda();
+        j["benjamin"] = x.get_benjamin();
+        j["brandling"] = x.get_brandling();
+        j["epicurishly"] = x.get_epicurishly();
+        j["eremochaetous"] = x.get_eremochaetous();
+        j["marten"] = x.get_marten();
+        j["monocline"] = x.get_monocline();
+        j["Olea"] = x.get_olea();
+        j["palgat"] = x.get_palgat();
+        j["pennyworth"] = x.get_pennyworth();
+        j["pioury"] = x.get_pioury();
+        j["pragmatistic"] = x.get_pragmatistic();
+        j["stylelessness"] = x.get_stylelessness();
+        j["systematical"] = x.get_systematical();
+        j["thready"] = x.get_thready();
+        j["uncontemporary"] = x.get_uncontemporary();
+        j["uncouched"] = x.get_uncouched();
+        j["uninhabitedness"] = x.get_uninhabitedness();
+    }
+
+    inline void from_json(const json & j, LadronismClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acclaimer(get_untyped(j, "acclaimer"));
+        x.set_achree(get_untyped(j, "achree"));
+        x.set_base(get_untyped(j, "base"));
+        x.set_conundrumize(get_untyped(j, "conundrumize"));
+        x.set_degerminator(get_untyped(j, "degerminator"));
+        x.set_describable(get_untyped(j, "describable"));
+        x.set_exasperatedly(get_untyped(j, "exasperatedly"));
+        x.set_heroine(get_untyped(j, "heroine"));
+        x.set_indazin(get_untyped(j, "indazin"));
+        x.set_luteous(get_untyped(j, "luteous"));
+        x.set_papular(get_untyped(j, "papular"));
+        x.set_pritch(get_untyped(j, "pritch"));
+        x.set_prodenia(get_untyped(j, "Prodenia"));
+        x.set_seege(get_untyped(j, "seege"));
+        x.set_shopgirl(get_untyped(j, "shopgirl"));
+        x.set_tragedietta(get_untyped(j, "tragedietta"));
+        x.set_unsparse(get_untyped(j, "unsparse"));
+        x.set_uplook(get_untyped(j, "uplook"));
+        x.set_vermiformis(get_untyped(j, "vermiformis"));
+        x.set_whafabout(get_untyped(j, "whafabout"));
+    }
+
+    inline void to_json(json & j, const LadronismClass & x) {
+        j = json::object();
+        j["acclaimer"] = x.get_acclaimer();
+        j["achree"] = x.get_achree();
+        j["base"] = x.get_base();
+        j["conundrumize"] = x.get_conundrumize();
+        j["degerminator"] = x.get_degerminator();
+        j["describable"] = x.get_describable();
+        j["exasperatedly"] = x.get_exasperatedly();
+        j["heroine"] = x.get_heroine();
+        j["indazin"] = x.get_indazin();
+        j["luteous"] = x.get_luteous();
+        j["papular"] = x.get_papular();
+        j["pritch"] = x.get_pritch();
+        j["Prodenia"] = x.get_prodenia();
+        j["seege"] = x.get_seege();
+        j["shopgirl"] = x.get_shopgirl();
+        j["tragedietta"] = x.get_tragedietta();
+        j["unsparse"] = x.get_unsparse();
+        j["uplook"] = x.get_uplook();
+        j["vermiformis"] = x.get_vermiformis();
+        j["whafabout"] = x.get_whafabout();
+    }
+
+    inline void from_json(const json & j, LandlubberlyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acropoleis(get_untyped(j, "acropoleis"));
+        x.set_aminate(get_untyped(j, "aminate"));
+        x.set_amyraldism(get_untyped(j, "Amyraldism"));
+        x.set_bipenniform(get_untyped(j, "bipenniform"));
+        x.set_bugre(get_untyped(j, "bugre"));
+        x.set_calycule(get_untyped(j, "calycule"));
+        x.set_caoutchouc(get_untyped(j, "caoutchouc"));
+        x.set_disprover(get_untyped(j, "disprover"));
+        x.set_fitroot(get_untyped(j, "fitroot"));
+        x.set_fulgently(get_untyped(j, "fulgently"));
+        x.set_kickup(get_untyped(j, "kickup"));
+        x.set_laevoversion(get_untyped(j, "laevoversion"));
+        x.set_moter(get_untyped(j, "moter"));
+        x.set_objectivity(get_untyped(j, "objectivity"));
+        x.set_posterity(get_untyped(j, "posterity"));
+        x.set_postnuptial(get_untyped(j, "postnuptial"));
+        x.set_precedentary(get_untyped(j, "precedentary"));
+        x.set_saddling(get_untyped(j, "saddling"));
+        x.set_subcurrent(get_untyped(j, "subcurrent"));
+        x.set_unrecriminative(get_untyped(j, "unrecriminative"));
+    }
+
+    inline void to_json(json & j, const LandlubberlyClass & x) {
+        j = json::object();
+        j["acropoleis"] = x.get_acropoleis();
+        j["aminate"] = x.get_aminate();
+        j["Amyraldism"] = x.get_amyraldism();
+        j["bipenniform"] = x.get_bipenniform();
+        j["bugre"] = x.get_bugre();
+        j["calycule"] = x.get_calycule();
+        j["caoutchouc"] = x.get_caoutchouc();
+        j["disprover"] = x.get_disprover();
+        j["fitroot"] = x.get_fitroot();
+        j["fulgently"] = x.get_fulgently();
+        j["kickup"] = x.get_kickup();
+        j["laevoversion"] = x.get_laevoversion();
+        j["moter"] = x.get_moter();
+        j["objectivity"] = x.get_objectivity();
+        j["posterity"] = x.get_posterity();
+        j["postnuptial"] = x.get_postnuptial();
+        j["precedentary"] = x.get_precedentary();
+        j["saddling"] = x.get_saddling();
+        j["subcurrent"] = x.get_subcurrent();
+        j["unrecriminative"] = x.get_unrecriminative();
+    }
+
+    inline void from_json(const json & j, LupusClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chlorioninae(get_stack_optional<int64_t>(j, "Chlorioninae"));
+        x.set_corvinae(get_stack_optional<int64_t>(j, "Corvinae"));
+        x.set_crassina(get_stack_optional<int64_t>(j, "Crassina"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_exiguity(get_stack_optional<int64_t>(j, "exiguity"));
+        x.set_farcist(get_stack_optional<int64_t>(j, "farcist"));
+        x.set_holographical(get_stack_optional<int64_t>(j, "holographical"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_ichthyophagan(get_stack_optional<int64_t>(j, "ichthyophagan"));
+        x.set_implacable(get_stack_optional<int64_t>(j, "implacable"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_outshiner(get_stack_optional<int64_t>(j, "outshiner"));
+        x.set_overweather(get_stack_optional<int64_t>(j, "overweather"));
+        x.set_protonegroid(get_stack_optional<int64_t>(j, "protonegroid"));
+        x.set_shallowish(get_stack_optional<int64_t>(j, "shallowish"));
+        x.set_snoke(get_stack_optional<int64_t>(j, "snoke"));
+        x.set_snout(get_stack_optional<int64_t>(j, "snout"));
+        x.set_surveillance(get_stack_optional<int64_t>(j, "surveillance"));
+        x.set_threshingtime(get_stack_optional<int64_t>(j, "threshingtime"));
+        x.set_thysanocarpus(get_stack_optional<int64_t>(j, "Thysanocarpus"));
+        x.set_unsignificantly(get_stack_optional<int64_t>(j, "unsignificantly"));
+        x.set_unsnap(get_stack_optional<int64_t>(j, "unsnap"));
+        x.set_vendible(get_stack_optional<int64_t>(j, "vendible"));
+    }
+
+    inline void to_json(json & j, const LupusClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["Chlorioninae"] = x.get_chlorioninae();
+        j["Corvinae"] = x.get_corvinae();
+        j["Crassina"] = x.get_crassina();
+        j["disdiapason"] = x.get_disdiapason();
+        j["exiguity"] = x.get_exiguity();
+        j["farcist"] = x.get_farcist();
+        j["holographical"] = x.get_holographical();
+        j["homocerc"] = x.get_homocerc();
+        j["ichthyophagan"] = x.get_ichthyophagan();
+        j["implacable"] = x.get_implacable();
+        j["nonbookish"] = x.get_nonbookish();
+        j["outshiner"] = x.get_outshiner();
+        j["overweather"] = x.get_overweather();
+        j["protonegroid"] = x.get_protonegroid();
+        j["shallowish"] = x.get_shallowish();
+        j["snoke"] = x.get_snoke();
+        j["snout"] = x.get_snout();
+        j["surveillance"] = x.get_surveillance();
+        j["threshingtime"] = x.get_threshingtime();
+        j["Thysanocarpus"] = x.get_thysanocarpus();
+        j["unsignificantly"] = x.get_unsignificantly();
+        j["unsnap"] = x.get_unsnap();
+        j["vendible"] = x.get_vendible();
+    }
+
+    inline void from_json(const json & j, Maslin& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alicant(get_stack_optional<int64_t>(j, "Alicant"));
+        x.set_antiatonement(get_untyped(j, "antiatonement"));
+        x.set_anticorrosive(get_stack_optional<int64_t>(j, "anticorrosive"));
+        x.set_aphidozer(get_untyped(j, "aphidozer"));
+        x.set_bakuninist(get_untyped(j, "Bakuninist"));
+        x.set_be(get_stack_optional<int64_t>(j, "be"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chub(get_stack_optional<int64_t>(j, "chub"));
+        x.set_cuprosilicon(get_stack_optional<int64_t>(j, "cuprosilicon"));
+        x.set_curtailedly(get_stack_optional<int64_t>(j, "curtailedly"));
+        x.set_dellenite(get_stack_optional<int64_t>(j, "dellenite"));
+        x.set_dimitry(get_stack_optional<int64_t>(j, "Dimitry"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_edifying(get_untyped(j, "edifying"));
+        x.set_ethmoiditis(get_stack_optional<int64_t>(j, "ethmoiditis"));
+        x.set_gastralgy(get_untyped(j, "gastralgy"));
+        x.set_goatherd(get_stack_optional<int64_t>(j, "goatherd"));
+        x.set_hammerdress(get_stack_optional<int64_t>(j, "hammerdress"));
+        x.set_hangfire(get_untyped(j, "hangfire"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_lacunosity(get_stack_optional<int64_t>(j, "lacunosity"));
+        x.set_longiloquence(get_untyped(j, "longiloquence"));
+        x.set_mameliere(get_stack_optional<int64_t>(j, "mameliere"));
+        x.set_motherless(get_untyped(j, "motherless"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_noncorrodible(get_untyped(j, "noncorrodible"));
+        x.set_nonsensicality(get_untyped(j, "nonsensicality"));
+        x.set_oafishly(get_stack_optional<int64_t>(j, "oafishly"));
+        x.set_pfund(get_untyped(j, "pfund"));
+        x.set_preadvisory(get_untyped(j, "preadvisory"));
+        x.set_retroflexed(get_untyped(j, "retroflexed"));
+        x.set_saccharulmic(get_stack_optional<int64_t>(j, "saccharulmic"));
+        x.set_scowlful(get_stack_optional<int64_t>(j, "scowlful"));
+        x.set_secluded(get_untyped(j, "secluded"));
+        x.set_slackage(get_untyped(j, "slackage"));
+        x.set_sphaeridial(get_stack_optional<int64_t>(j, "sphaeridial"));
+        x.set_spondulics(get_untyped(j, "spondulics"));
+        x.set_subsecive(get_stack_optional<int64_t>(j, "subsecive"));
+        x.set_swellmobsman(get_untyped(j, "swellmobsman"));
+        x.set_trachyglossate(get_stack_optional<int64_t>(j, "trachyglossate"));
+        x.set_trialogue(get_untyped(j, "trialogue"));
+        x.set_unassuaged(get_stack_optional<int64_t>(j, "unassuaged"));
+        x.set_ungross(get_untyped(j, "ungross"));
+        x.set_unjudiciously(get_untyped(j, "unjudiciously"));
+    }
+
+    inline void to_json(json & j, const Maslin & x) {
+        j = json::object();
+        j["Alicant"] = x.get_alicant();
+        j["antiatonement"] = x.get_antiatonement();
+        j["anticorrosive"] = x.get_anticorrosive();
+        j["aphidozer"] = x.get_aphidozer();
+        j["Bakuninist"] = x.get_bakuninist();
+        j["be"] = x.get_be();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chub"] = x.get_chub();
+        j["cuprosilicon"] = x.get_cuprosilicon();
+        j["curtailedly"] = x.get_curtailedly();
+        j["dellenite"] = x.get_dellenite();
+        j["Dimitry"] = x.get_dimitry();
+        j["disdiapason"] = x.get_disdiapason();
+        j["edifying"] = x.get_edifying();
+        j["ethmoiditis"] = x.get_ethmoiditis();
+        j["gastralgy"] = x.get_gastralgy();
+        j["goatherd"] = x.get_goatherd();
+        j["hammerdress"] = x.get_hammerdress();
+        j["hangfire"] = x.get_hangfire();
+        j["homocerc"] = x.get_homocerc();
+        j["lacunosity"] = x.get_lacunosity();
+        j["longiloquence"] = x.get_longiloquence();
+        j["mameliere"] = x.get_mameliere();
+        j["motherless"] = x.get_motherless();
+        j["nonbookish"] = x.get_nonbookish();
+        j["noncorrodible"] = x.get_noncorrodible();
+        j["nonsensicality"] = x.get_nonsensicality();
+        j["oafishly"] = x.get_oafishly();
+        j["pfund"] = x.get_pfund();
+        j["preadvisory"] = x.get_preadvisory();
+        j["retroflexed"] = x.get_retroflexed();
+        j["saccharulmic"] = x.get_saccharulmic();
+        j["scowlful"] = x.get_scowlful();
+        j["secluded"] = x.get_secluded();
+        j["slackage"] = x.get_slackage();
+        j["sphaeridial"] = x.get_sphaeridial();
+        j["spondulics"] = x.get_spondulics();
+        j["subsecive"] = x.get_subsecive();
+        j["swellmobsman"] = x.get_swellmobsman();
+        j["trachyglossate"] = x.get_trachyglossate();
+        j["trialogue"] = x.get_trialogue();
+        j["unassuaged"] = x.get_unassuaged();
+        j["ungross"] = x.get_ungross();
+        j["unjudiciously"] = x.get_unjudiciously();
+    }
+
+    inline void from_json(const json & j, MonaziteClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, const MonaziteClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(const json & j, MonotheisticallyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_blaspheme(get_untyped(j, "blaspheme"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_celiosalpingectomy(get_untyped(j, "celiosalpingectomy"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_consummativeness(get_untyped(j, "consummativeness"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_egestive(get_untyped(j, "egestive"));
+        x.set_enchylema(get_untyped(j, "enchylema"));
+        x.set_gasconade(get_untyped(j, "gasconade"));
+        x.set_holidayer(get_untyped(j, "holidayer"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_intuitionalism(get_untyped(j, "intuitionalism"));
+        x.set_lophiostomate(get_untyped(j, "lophiostomate"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_nonvolition(get_untyped(j, "nonvolition"));
+        x.set_palatableness(get_untyped(j, "palatableness"));
+        x.set_pimpery(get_untyped(j, "pimpery"));
+        x.set_previolation(get_untyped(j, "previolation"));
+        x.set_reconveyance(get_untyped(j, "reconveyance"));
+        x.set_registership(get_untyped(j, "registership"));
+        x.set_rhyacolite(get_untyped(j, "rhyacolite"));
+        x.set_smithereens(get_untyped(j, "smithereens"));
+        x.set_superedification(get_untyped(j, "superedification"));
+        x.set_trust(get_untyped(j, "trust"));
+        x.set_whitestone(get_untyped(j, "whitestone"));
+    }
+
+    inline void to_json(json & j, const MonotheisticallyClass & x) {
+        j = json::object();
+        j["blaspheme"] = x.get_blaspheme();
+        j["catharticalness"] = x.get_catharticalness();
+        j["celiosalpingectomy"] = x.get_celiosalpingectomy();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["consummativeness"] = x.get_consummativeness();
+        j["disdiapason"] = x.get_disdiapason();
+        j["egestive"] = x.get_egestive();
+        j["enchylema"] = x.get_enchylema();
+        j["gasconade"] = x.get_gasconade();
+        j["holidayer"] = x.get_holidayer();
+        j["homocerc"] = x.get_homocerc();
+        j["intuitionalism"] = x.get_intuitionalism();
+        j["lophiostomate"] = x.get_lophiostomate();
+        j["nonbookish"] = x.get_nonbookish();
+        j["nonvolition"] = x.get_nonvolition();
+        j["palatableness"] = x.get_palatableness();
+        j["pimpery"] = x.get_pimpery();
+        j["previolation"] = x.get_previolation();
+        j["reconveyance"] = x.get_reconveyance();
+        j["registership"] = x.get_registership();
+        j["rhyacolite"] = x.get_rhyacolite();
+        j["smithereens"] = x.get_smithereens();
+        j["superedification"] = x.get_superedification();
+        j["trust"] = x.get_trust();
+        j["whitestone"] = x.get_whitestone();
+    }
+
+    inline void from_json(const json & j, Noncontributing& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_estevin(j.at("estevin").get<std::string>());
+        x.set_jolterhead(j.at("jolterhead").get<double>());
+        x.set_sauternes(j.at("sauternes").get<int64_t>());
+        x.set_sparsely(j.at("sparsely").get<bool>());
+        x.set_unrequested(get_untyped(j, "unrequested"));
+    }
+
+    inline void to_json(json & j, const Noncontributing & x) {
+        j = json::object();
+        j["estevin"] = x.get_estevin();
+        j["jolterhead"] = x.get_jolterhead();
+        j["sauternes"] = x.get_sauternes();
+        j["sparsely"] = x.get_sparsely();
+        j["unrequested"] = x.get_unrequested();
+    }
+
+    inline void from_json(const json & j, OccupationalistClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_beholdable(get_untyped(j, "beholdable"));
+        x.set_brotuliform(get_untyped(j, "brotuliform"));
+        x.set_chimakum(get_untyped(j, "Chimakum"));
+        x.set_doodler(get_untyped(j, "doodler"));
+        x.set_emulsin(get_untyped(j, "emulsin"));
+        x.set_fin(get_untyped(j, "Fin"));
+        x.set_flourishing(get_untyped(j, "flourishing"));
+        x.set_flueless(get_untyped(j, "flueless"));
+        x.set_furtively(get_untyped(j, "furtively"));
+        x.set_gritter(get_untyped(j, "gritter"));
+        x.set_interwish(get_untyped(j, "interwish"));
+        x.set_monoxylic(get_untyped(j, "monoxylic"));
+        x.set_myristic(get_untyped(j, "myristic"));
+        x.set_nightwear(get_untyped(j, "nightwear"));
+        x.set_peruser(get_untyped(j, "peruser"));
+        x.set_theoastrological(get_untyped(j, "theoastrological"));
+        x.set_thumby(get_untyped(j, "thumby"));
+        x.set_tingitid(get_untyped(j, "tingitid"));
+        x.set_trailless(get_untyped(j, "trailless"));
+        x.set_unpocketed(get_untyped(j, "unpocketed"));
+    }
+
+    inline void to_json(json & j, const OccupationalistClass & x) {
+        j = json::object();
+        j["beholdable"] = x.get_beholdable();
+        j["brotuliform"] = x.get_brotuliform();
+        j["Chimakum"] = x.get_chimakum();
+        j["doodler"] = x.get_doodler();
+        j["emulsin"] = x.get_emulsin();
+        j["Fin"] = x.get_fin();
+        j["flourishing"] = x.get_flourishing();
+        j["flueless"] = x.get_flueless();
+        j["furtively"] = x.get_furtively();
+        j["gritter"] = x.get_gritter();
+        j["interwish"] = x.get_interwish();
+        j["monoxylic"] = x.get_monoxylic();
+        j["myristic"] = x.get_myristic();
+        j["nightwear"] = x.get_nightwear();
+        j["peruser"] = x.get_peruser();
+        j["theoastrological"] = x.get_theoastrological();
+        j["thumby"] = x.get_thumby();
+        j["tingitid"] = x.get_tingitid();
+        j["trailless"] = x.get_trailless();
+        j["unpocketed"] = x.get_unpocketed();
+    }
+
+    inline void from_json(const json & j, OutrivalClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_adroitly(get_untyped(j, "adroitly"));
+        x.set_bridehood(get_untyped(j, "bridehood"));
+        x.set_castoroides(get_untyped(j, "Castoroides"));
+        x.set_czechoslovak(get_untyped(j, "Czechoslovak"));
+        x.set_diagenesis(get_untyped(j, "diagenesis"));
+        x.set_dihexahedron(get_untyped(j, "dihexahedron"));
+        x.set_dopester(get_untyped(j, "dopester"));
+        x.set_eumerism(get_untyped(j, "eumerism"));
+        x.set_flyness(get_untyped(j, "flyness"));
+        x.set_fouler(get_untyped(j, "fouler"));
+        x.set_laudanosine(get_untyped(j, "laudanosine"));
+        x.set_lingulidae(get_untyped(j, "Lingulidae"));
+        x.set_minutary(get_untyped(j, "minutary"));
+        x.set_mitra(get_untyped(j, "mitra"));
+        x.set_opisthorchiasis(get_untyped(j, "opisthorchiasis"));
+        x.set_pensively(get_untyped(j, "pensively"));
+        x.set_pubigerous(get_untyped(j, "pubigerous"));
+        x.set_rebellious(get_untyped(j, "rebellious"));
+        x.set_recodify(get_untyped(j, "recodify"));
+        x.set_unpaced(get_untyped(j, "unpaced"));
+    }
+
+    inline void to_json(json & j, const OutrivalClass & x) {
+        j = json::object();
+        j["adroitly"] = x.get_adroitly();
+        j["bridehood"] = x.get_bridehood();
+        j["Castoroides"] = x.get_castoroides();
+        j["Czechoslovak"] = x.get_czechoslovak();
+        j["diagenesis"] = x.get_diagenesis();
+        j["dihexahedron"] = x.get_dihexahedron();
+        j["dopester"] = x.get_dopester();
+        j["eumerism"] = x.get_eumerism();
+        j["flyness"] = x.get_flyness();
+        j["fouler"] = x.get_fouler();
+        j["laudanosine"] = x.get_laudanosine();
+        j["Lingulidae"] = x.get_lingulidae();
+        j["minutary"] = x.get_minutary();
+        j["mitra"] = x.get_mitra();
+        j["opisthorchiasis"] = x.get_opisthorchiasis();
+        j["pensively"] = x.get_pensively();
+        j["pubigerous"] = x.get_pubigerous();
+        j["rebellious"] = x.get_rebellious();
+        j["recodify"] = x.get_recodify();
+        j["unpaced"] = x.get_unpaced();
+    }
+
+    inline void from_json(const json & j, PiaculumClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alada(get_stack_optional<int64_t>(j, "alada"));
+        x.set_amphistomous(get_stack_optional<int64_t>(j, "amphistomous"));
+        x.set_boysenberry(get_stack_optional<int64_t>(j, "boysenberry"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_decardinalize(get_stack_optional<int64_t>(j, "decardinalize"));
+        x.set_discouragement(get_stack_optional<int64_t>(j, "discouragement"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_doitrified(get_stack_optional<int64_t>(j, "doitrified"));
+        x.set_hexaspermous(get_stack_optional<int64_t>(j, "hexaspermous"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_insinking(get_stack_optional<int64_t>(j, "insinking"));
+        x.set_loathfulness(get_stack_optional<int64_t>(j, "loathfulness"));
+        x.set_miasmatical(get_stack_optional<int64_t>(j, "miasmatical"));
+        x.set_neurofibril(get_stack_optional<int64_t>(j, "neurofibril"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_phonendoscope(get_stack_optional<int64_t>(j, "phonendoscope"));
+        x.set_pilferment(get_stack_optional<int64_t>(j, "pilferment"));
+        x.set_predismissory(get_stack_optional<int64_t>(j, "predismissory"));
+        x.set_preinscription(get_stack_optional<int64_t>(j, "preinscription"));
+        x.set_quotative(get_stack_optional<int64_t>(j, "quotative"));
+        x.set_sienna(get_stack_optional<int64_t>(j, "sienna"));
+        x.set_thorax(get_stack_optional<int64_t>(j, "thorax"));
+        x.set_yachting(get_stack_optional<int64_t>(j, "yachting"));
+        x.set_zipper(get_stack_optional<int64_t>(j, "Zipper"));
+    }
+
+    inline void to_json(json & j, const PiaculumClass & x) {
+        j = json::object();
+        j["alada"] = x.get_alada();
+        j["amphistomous"] = x.get_amphistomous();
+        j["boysenberry"] = x.get_boysenberry();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["decardinalize"] = x.get_decardinalize();
+        j["discouragement"] = x.get_discouragement();
+        j["disdiapason"] = x.get_disdiapason();
+        j["doitrified"] = x.get_doitrified();
+        j["hexaspermous"] = x.get_hexaspermous();
+        j["homocerc"] = x.get_homocerc();
+        j["insinking"] = x.get_insinking();
+        j["loathfulness"] = x.get_loathfulness();
+        j["miasmatical"] = x.get_miasmatical();
+        j["neurofibril"] = x.get_neurofibril();
+        j["nonbookish"] = x.get_nonbookish();
+        j["phonendoscope"] = x.get_phonendoscope();
+        j["pilferment"] = x.get_pilferment();
+        j["predismissory"] = x.get_predismissory();
+        j["preinscription"] = x.get_preinscription();
+        j["quotative"] = x.get_quotative();
+        j["sienna"] = x.get_sienna();
+        j["thorax"] = x.get_thorax();
+        j["yachting"] = x.get_yachting();
+        j["Zipper"] = x.get_zipper();
+    }
+
+    inline void from_json(const json & j, Pneumocele& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_carbonarism(get_untyped(j, "Carbonarism"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_cineolic(get_untyped(j, "cineolic"));
+        x.set_cobbly(get_untyped(j, "cobbly"));
+        x.set_conchyliferous(get_untyped(j, "conchyliferous"));
+        x.set_congregation(get_untyped(j, "congregation"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_enterotomy(get_untyped(j, "enterotomy"));
+        x.set_entophytal(get_untyped(j, "entophytal"));
+        x.set_fewtrils(get_untyped(j, "fewtrils"));
+        x.set_herem(get_untyped(j, "herem"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_koniga(get_untyped(j, "Koniga"));
+        x.set_meticulosity(get_untyped(j, "meticulosity"));
+        x.set_micky(get_untyped(j, "Micky"));
+        x.set_mismarriage(get_untyped(j, "mismarriage"));
+        x.set_neurotrophic(get_untyped(j, "neurotrophic"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_persuasively(get_untyped(j, "persuasively"));
+        x.set_replaceable(get_untyped(j, "replaceable"));
+        x.set_silex(get_untyped(j, "silex"));
+        x.set_taillight(get_untyped(j, "taillight"));
+        x.set_unjealous(get_untyped(j, "unjealous"));
+        x.set_visitorial(get_untyped(j, "visitorial"));
+    }
+
+    inline void to_json(json & j, const Pneumocele & x) {
+        j = json::object();
+        j["Carbonarism"] = x.get_carbonarism();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["cineolic"] = x.get_cineolic();
+        j["cobbly"] = x.get_cobbly();
+        j["conchyliferous"] = x.get_conchyliferous();
+        j["congregation"] = x.get_congregation();
+        j["disdiapason"] = x.get_disdiapason();
+        j["enterotomy"] = x.get_enterotomy();
+        j["entophytal"] = x.get_entophytal();
+        j["fewtrils"] = x.get_fewtrils();
+        j["herem"] = x.get_herem();
+        j["homocerc"] = x.get_homocerc();
+        j["Koniga"] = x.get_koniga();
+        j["meticulosity"] = x.get_meticulosity();
+        j["Micky"] = x.get_micky();
+        j["mismarriage"] = x.get_mismarriage();
+        j["neurotrophic"] = x.get_neurotrophic();
+        j["nonbookish"] = x.get_nonbookish();
+        j["persuasively"] = x.get_persuasively();
+        j["replaceable"] = x.get_replaceable();
+        j["silex"] = x.get_silex();
+        j["taillight"] = x.get_taillight();
+        j["unjealous"] = x.get_unjealous();
+        j["visitorial"] = x.get_visitorial();
+    }
+
+    inline void from_json(const json & j, PotwhiskyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_arciform(get_untyped(j, "arciform"));
+        x.set_cresolin(get_untyped(j, "cresolin"));
+        x.set_disheartener(get_untyped(j, "disheartener"));
+        x.set_disproportionable(get_untyped(j, "disproportionable"));
+        x.set_euchorda(get_untyped(j, "Euchorda"));
+        x.set_ferryway(get_untyped(j, "ferryway"));
+        x.set_filamentiferous(get_untyped(j, "filamentiferous"));
+        x.set_flemish(get_untyped(j, "flemish"));
+        x.set_forgainst(get_untyped(j, "forgainst"));
+        x.set_grainering(get_untyped(j, "grainering"));
+        x.set_irrevoluble(get_untyped(j, "irrevoluble"));
+        x.set_kindredship(get_untyped(j, "kindredship"));
+        x.set_pinguitudinous(get_untyped(j, "pinguitudinous"));
+        x.set_simpletonic(get_untyped(j, "simpletonic"));
+        x.set_singsong(get_untyped(j, "singsong"));
+        x.set_submergement(get_untyped(j, "submergement"));
+        x.set_supraoesophagal(get_untyped(j, "supraoesophagal"));
+        x.set_thrashel(get_untyped(j, "thrashel"));
+        x.set_tyremesis(get_untyped(j, "tyremesis"));
+        x.set_yoruba(get_untyped(j, "Yoruba"));
+    }
+
+    inline void to_json(json & j, const PotwhiskyClass & x) {
+        j = json::object();
+        j["arciform"] = x.get_arciform();
+        j["cresolin"] = x.get_cresolin();
+        j["disheartener"] = x.get_disheartener();
+        j["disproportionable"] = x.get_disproportionable();
+        j["Euchorda"] = x.get_euchorda();
+        j["ferryway"] = x.get_ferryway();
+        j["filamentiferous"] = x.get_filamentiferous();
+        j["flemish"] = x.get_flemish();
+        j["forgainst"] = x.get_forgainst();
+        j["grainering"] = x.get_grainering();
+        j["irrevoluble"] = x.get_irrevoluble();
+        j["kindredship"] = x.get_kindredship();
+        j["pinguitudinous"] = x.get_pinguitudinous();
+        j["simpletonic"] = x.get_simpletonic();
+        j["singsong"] = x.get_singsong();
+        j["submergement"] = x.get_submergement();
+        j["supraoesophagal"] = x.get_supraoesophagal();
+        j["thrashel"] = x.get_thrashel();
+        j["tyremesis"] = x.get_tyremesis();
+        j["Yoruba"] = x.get_yoruba();
+    }
+
+    inline void from_json(const json & j, PrefreshmanClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_azorubine(get_untyped(j, "azorubine"));
+        x.set_choroiditis(get_untyped(j, "choroiditis"));
+        x.set_coagulatory(get_untyped(j, "coagulatory"));
+        x.set_cyclorama(get_untyped(j, "cyclorama"));
+        x.set_dolphus(get_untyped(j, "Dolphus"));
+        x.set_duckhearted(get_untyped(j, "duckhearted"));
+        x.set_ficus(get_untyped(j, "Ficus"));
+        x.set_gemaric(get_untyped(j, "Gemaric"));
+        x.set_jugation(get_untyped(j, "jugation"));
+        x.set_myoliposis(get_untyped(j, "myoliposis"));
+        x.set_nonnomination(get_untyped(j, "nonnomination"));
+        x.set_palay(get_untyped(j, "palay"));
+        x.set_pentactinal(get_untyped(j, "pentactinal"));
+        x.set_phaet(get_untyped(j, "Phaet"));
+        x.set_piquant(get_untyped(j, "piquant"));
+        x.set_registration(get_untyped(j, "registration"));
+        x.set_remancipation(get_untyped(j, "remancipation"));
+        x.set_scutatiform(get_untyped(j, "scutatiform"));
+        x.set_theodolite(get_untyped(j, "theodolite"));
+        x.set_underward(get_untyped(j, "underward"));
+    }
+
+    inline void to_json(json & j, const PrefreshmanClass & x) {
+        j = json::object();
+        j["azorubine"] = x.get_azorubine();
+        j["choroiditis"] = x.get_choroiditis();
+        j["coagulatory"] = x.get_coagulatory();
+        j["cyclorama"] = x.get_cyclorama();
+        j["Dolphus"] = x.get_dolphus();
+        j["duckhearted"] = x.get_duckhearted();
+        j["Ficus"] = x.get_ficus();
+        j["Gemaric"] = x.get_gemaric();
+        j["jugation"] = x.get_jugation();
+        j["myoliposis"] = x.get_myoliposis();
+        j["nonnomination"] = x.get_nonnomination();
+        j["palay"] = x.get_palay();
+        j["pentactinal"] = x.get_pentactinal();
+        j["Phaet"] = x.get_phaet();
+        j["piquant"] = x.get_piquant();
+        j["registration"] = x.get_registration();
+        j["remancipation"] = x.get_remancipation();
+        j["scutatiform"] = x.get_scutatiform();
+        j["theodolite"] = x.get_theodolite();
+        j["underward"] = x.get_underward();
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_juror(j.at("juror").get<std::vector<JurorElement>>());
+        x.set_kongoni(j.at("kongoni").get<std::vector<Kongoni>>());
+        x.set_ladronism(j.at("ladronism").get<std::vector<LadronismElement>>());
+        x.set_landlubberly(j.at("landlubberly").get<std::vector<LandlubberlyElement>>());
+        x.set_listener(j.at("listener").get<std::vector<Listener>>());
+        x.set_lupus(j.at("lupus").get<std::vector<LupusElement>>());
+        x.set_maslin(j.at("maslin").get<std::vector<Maslin>>());
+        x.set_monazite(j.at("monazite").get<std::vector<MonaziteElement>>());
+        x.set_monoliteral(j.at("monoliteral").get<std::vector<Monoliteral>>());
+        x.set_monotheistically(j.at("monotheistically").get<std::vector<MonotheisticallyElement>>());
+        x.set_montage(j.at("montage").get<std::vector<Montage>>());
+        x.set_moralness(j.at("moralness").get<std::vector<Moralness>>());
+        x.set_mowra(j.at("mowra").get<std::vector<std::optional<MonaziteClass>>>());
+        x.set_mulishly(j.at("mulishly").get<std::vector<Mulishly>>());
+        x.set_myoscope(j.at("myoscope").get<std::vector<Myoscope>>());
+        x.set_nach(j.at("nach").get<std::vector<std::optional<std::vector<std::optional<int64_t>>>>>());
+        x.set_neuromastic(j.at("neuromastic").get<std::vector<Neuromastic>>());
+        x.set_noncontributing(j.at("noncontributing").get<std::vector<Noncontributing>>());
+        x.set_nonnervous(j.at("nonnervous").get<std::vector<Nonnervous>>());
+        x.set_nonvaluation(j.at("nonvaluation").get<std::vector<Nonvaluation>>());
+        x.set_occupationalist(j.at("occupationalist").get<std::vector<OccupationalistElement>>());
+        x.set_outrival(j.at("outrival").get<std::vector<OutrivalElement>>());
+        x.set_paleographically(j.at("paleographically").get<std::vector<Paleographically>>());
+        x.set_pamphletwise(j.at("pamphletwise").get<std::vector<Pamphletwise>>());
+        x.set_pediatrics(j.at("pediatrics").get<std::vector<Pediatric>>());
+        x.set_perceptive(j.at("perceptive").get<std::vector<bool>>());
+        x.set_piaculum(j.at("piaculum").get<std::vector<PiaculumElement>>());
+        x.set_piccadilly(j.at("piccadilly").get<std::vector<Piccadilly>>());
+        x.set_piffler(j.at("piffler").get<std::vector<Piffler>>());
+        x.set_pithful(j.at("pithful").get<std::vector<Pithful>>());
+        x.set_placuntitis(j.at("placuntitis").get<std::vector<Placuntiti>>());
+        x.set_plectopterous(j.at("plectopterous").get<std::vector<Plectopterous>>());
+        x.set_pneumocele(j.at("pneumocele").get<std::vector<std::optional<Pneumocele>>>());
+        x.set_poliorcetic(j.at("poliorcetic").get<std::vector<Poliorcetic>>());
+        x.set_poormaster(j.at("poormaster").get<std::vector<Poormaster>>());
+        x.set_potwhisky(j.at("potwhisky").get<std::vector<PotwhiskyElement>>());
+        x.set_practicalizer(j.at("practicalizer").get<std::vector<Practicalizer>>());
+        x.set_prefreshman(j.at("prefreshman").get<std::vector<PrefreshmanElement>>());
+        x.set_prehensility(j.at("prehensility").get<std::vector<Prehensility>>());
+        x.set_prevoidance(j.at("prevoidance").get<std::vector<Prevoidance>>());
+        x.set_probant(j.at("probant").get<std::vector<std::map<std::string, std::optional<int64_t>>>>());
+        x.set_protext(j.at("protext").get<std::vector<Protext>>());
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["juror"] = x.get_juror();
+        j["kongoni"] = x.get_kongoni();
+        j["ladronism"] = x.get_ladronism();
+        j["landlubberly"] = x.get_landlubberly();
+        j["listener"] = x.get_listener();
+        j["lupus"] = x.get_lupus();
+        j["maslin"] = x.get_maslin();
+        j["monazite"] = x.get_monazite();
+        j["monoliteral"] = x.get_monoliteral();
+        j["monotheistically"] = x.get_monotheistically();
+        j["montage"] = x.get_montage();
+        j["moralness"] = x.get_moralness();
+        j["mowra"] = x.get_mowra();
+        j["mulishly"] = x.get_mulishly();
+        j["myoscope"] = x.get_myoscope();
+        j["nach"] = x.get_nach();
+        j["neuromastic"] = x.get_neuromastic();
+        j["noncontributing"] = x.get_noncontributing();
+        j["nonnervous"] = x.get_nonnervous();
+        j["nonvaluation"] = x.get_nonvaluation();
+        j["occupationalist"] = x.get_occupationalist();
+        j["outrival"] = x.get_outrival();
+        j["paleographically"] = x.get_paleographically();
+        j["pamphletwise"] = x.get_pamphletwise();
+        j["pediatrics"] = x.get_pediatrics();
+        j["perceptive"] = x.get_perceptive();
+        j["piaculum"] = x.get_piaculum();
+        j["piccadilly"] = x.get_piccadilly();
+        j["piffler"] = x.get_piffler();
+        j["pithful"] = x.get_pithful();
+        j["placuntitis"] = x.get_placuntitis();
+        j["plectopterous"] = x.get_plectopterous();
+        j["pneumocele"] = x.get_pneumocele();
+        j["poliorcetic"] = x.get_poliorcetic();
+        j["poormaster"] = x.get_poormaster();
+        j["potwhisky"] = x.get_potwhisky();
+        j["practicalizer"] = x.get_practicalizer();
+        j["prefreshman"] = x.get_prefreshman();
+        j["prehensility"] = x.get_prehensility();
+        j["prevoidance"] = x.get_prevoidance();
+        j["probant"] = x.get_probant();
+        j["protext"] = x.get_protext();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<bool, quicktype::JurorClass>>::from_json(const json & j, std::variant<bool, quicktype::JurorClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::JurorClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::JurorClass>>::to_json(json & j, const std::variant<bool, quicktype::JurorClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::JurorClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>>::from_json(const json & j, std::variant<quicktype::LadronismClass, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::LadronismClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LadronismClass, double, std::string>>::to_json(json & j, const std::variant<quicktype::LadronismClass, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LadronismClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>>::from_json(const json & j, std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::LandlubberlyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::LandlubberlyClass, int64_t>>::to_json(json & j, const std::variant<bool, quicktype::LandlubberlyClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::LandlubberlyClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LupusClass, int64_t>>::from_json(const json & j, std::variant<quicktype::LupusClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::LupusClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::LupusClass, int64_t>>::to_json(json & j, const std::variant<quicktype::LupusClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::LupusClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MonaziteClass, double>>::from_json(const json & j, std::variant<quicktype::MonaziteClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MonaziteClass, double>>::to_json(json & j, const std::variant<quicktype::MonaziteClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::from_json(const json & j, std::variant<std::vector<json>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::to_json(json & j, const std::variant<std::vector<json>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::MonotheisticallyClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonotheisticallyClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::MonotheisticallyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonotheisticallyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::string>>::from_json(const json & j, std::variant<std::vector<json>, double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::string>>::to_json(json & j, const std::variant<std::vector<json>, double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::from_json(const json & j, std::variant<std::vector<json>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::to_json(json & j, const std::variant<std::vector<json>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, bool, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t>>::from_json(const json & j, std::variant<bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t>>::to_json(json & j, const std::variant<bool, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, double>>::from_json(const json & j, std::variant<std::vector<json>, bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, double>>::to_json(json & j, const std::variant<std::vector<json>, bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::OccupationalistClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::OccupationalistClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::OccupationalistClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::OccupationalistClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::OccupationalistClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OutrivalClass, double>>::from_json(const json & j, std::variant<quicktype::OutrivalClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::OutrivalClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OutrivalClass, double>>::to_json(json & j, const std::variant<quicktype::OutrivalClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::OutrivalClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>>::from_json(const json & j, std::variant<double, std::map<std::string, std::optional<int64_t>>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, std::optional<int64_t>>>>::to_json(json & j, const std::variant<double, std::map<std::string, std::optional<int64_t>>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, std::optional<int64_t>>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(const json & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, const std::variant<bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PiaculumClass, double>>::from_json(const json & j, std::variant<quicktype::PiaculumClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::PiaculumClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PiaculumClass, double>>::to_json(json & j, const std::variant<quicktype::PiaculumClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PiaculumClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::from_json(const json & j, std::variant<double, std::string> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::string>>::to_json(json & j, const std::variant<double, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<int64_t>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<bool, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>>::from_json(const json & j, std::variant<quicktype::PotwhiskyClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::PotwhiskyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PotwhiskyClass, int64_t>>::to_json(json & j, const std::variant<quicktype::PotwhiskyClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PotwhiskyClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::MonaziteClass, std::string>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::MonaziteClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::PrefreshmanClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::PrefreshmanClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::PrefreshmanClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<std::vector<json>, bool, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::MonaziteClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::MonaziteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, quicktype::MonaziteClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<quicktype::MonaziteClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations4.json/code-format-with-struct--67c848c66185/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations4.json/code-format-with-struct--67c848c66185/quicktype.hpp
new file mode 100644
index 0000000..2bd1031
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations4.json/code-format-with-struct--67c848c66185/quicktype.hpp
@@ -0,0 +1,2711 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    using Protrusive = std::variant<std::vector<std::optional<int64_t>>, double>;
+
+    struct PulpitismClass {
+        nlohmann::json abnet;
+        nlohmann::json buckhorn;
+        nlohmann::json calciform;
+        nlohmann::json chelophore;
+        nlohmann::json cogitation;
+        nlohmann::json decreeable;
+        nlohmann::json despicable;
+        nlohmann::json isodiazo;
+        nlohmann::json jadedly;
+        nlohmann::json leptochlorite;
+        nlohmann::json nursling;
+        nlohmann::json palamedean;
+        nlohmann::json photoheliograph;
+        nlohmann::json pipewood;
+        nlohmann::json roberd;
+        nlohmann::json statable;
+        nlohmann::json superassume;
+        nlohmann::json syllabe;
+        nlohmann::json toughhead;
+        nlohmann::json underburn;
+    };
+
+    using PulpitismElement = std::variant<std::vector<int64_t>, PulpitismClass, double>;
+
+    struct PyodermiaClass {
+        nlohmann::json aphoristically;
+        nlohmann::json apophyllous;
+        nlohmann::json cognize;
+        nlohmann::json dermonosology;
+        nlohmann::json gyppo;
+        nlohmann::json ither;
+        nlohmann::json juglandaceous;
+        nlohmann::json litho;
+        nlohmann::json macropterous;
+        nlohmann::json photographer;
+        nlohmann::json romancing;
+        nlohmann::json rumness;
+        nlohmann::json somniloquist;
+        nlohmann::json stressfully;
+        nlohmann::json tactically;
+        nlohmann::json tracheophony;
+        nlohmann::json unappositely;
+        nlohmann::json unclothedly;
+        nlohmann::json unimplied;
+        nlohmann::json unsyncopated;
+    };
+
+    using PyodermiaElement = std::variant<PyodermiaClass, int64_t>;
+
+    struct QuebrachineClass {
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+    };
+
+    using QuebrachineElement = std::optional<std::variant<bool, QuebrachineClass>>;
+
+    using Querier = std::variant<bool, std::map<std::string, int64_t>>;
+
+    using Rebarbative = std::variant<std::vector<int64_t>, bool, double>;
+
+    struct Reimagine {
+        nlohmann::json adducible;
+        nlohmann::json anabolin;
+        nlohmann::json brainy;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json chrysamine;
+        std::optional<std::string> disdiapason;
+        nlohmann::json fluxweed;
+        nlohmann::json glaucine;
+        nlohmann::json grobianism;
+        nlohmann::json hermo;
+        nlohmann::json hieroglyphist;
+        std::optional<bool> homocerc;
+        nlohmann::json icteroid;
+        nlohmann::json immortal;
+        nlohmann::json impetulant;
+        nlohmann::json irrigate;
+        nlohmann::json myxedema;
+        nlohmann::json nonbookish;
+        nlohmann::json onyx;
+        nlohmann::json repasser;
+        nlohmann::json septomarginal;
+        nlohmann::json subdie;
+        nlohmann::json tibiometatarsal;
+        nlohmann::json waltzlike;
+    };
+
+    struct Ressaut {
+        std::string apperceptive;
+        std::string cuttoo;
+        std::string douser;
+        std::string drinkproof;
+        std::string forementioned;
+        std::string freesia;
+        std::string genevieve;
+        std::string hyperdiabolical;
+        std::string hypocone;
+        std::string irreverentially;
+        std::string jumart;
+        std::string mimosaceae;
+        std::string mollicrush;
+        std::string nedder;
+        std::string retinasphalt;
+        std::string sough;
+        std::string steading;
+        std::string theopaschitism;
+        std::string undurableness;
+        std::string unmingleable;
+    };
+
+    using Retrocervical = std::variant<std::vector<std::optional<int64_t>>, int64_t>;
+
+    using Revert = std::variant<bool, std::string>;
+
+    struct RewriteClass {
+        nlohmann::json accountancy;
+        nlohmann::json cacotrophic;
+        nlohmann::json contest;
+        nlohmann::json couthily;
+        nlohmann::json falculate;
+        nlohmann::json foreseize;
+        nlohmann::json hyades;
+        nlohmann::json lemnad;
+        nlohmann::json monotheistically;
+        nlohmann::json nonflying;
+        nlohmann::json ptenoglossa;
+        nlohmann::json repatch;
+        nlohmann::json rodman;
+        nlohmann::json strung;
+        nlohmann::json titmal;
+        nlohmann::json twalpennyworth;
+        nlohmann::json unblamable;
+        nlohmann::json vertical;
+        nlohmann::json whiggification;
+        nlohmann::json yardman;
+    };
+
+    using RewriteElement = std::variant<std::vector<nlohmann::json>, RewriteClass, double>;
+
+    using Saccoderm = std::optional<std::variant<std::vector<int64_t>, std::string>>;
+
+    struct SantirClass {
+        nlohmann::json admiredly;
+        nlohmann::json demicaponier;
+        nlohmann::json epitympanic;
+        nlohmann::json investitor;
+        nlohmann::json lupiform;
+        nlohmann::json monoflagellate;
+        nlohmann::json paleoethnic;
+        nlohmann::json prediscountable;
+        nlohmann::json rhetoricals;
+        nlohmann::json roomth;
+        nlohmann::json saccharose;
+        nlohmann::json septonasal;
+        nlohmann::json serpenticide;
+        nlohmann::json setarious;
+        nlohmann::json spaework;
+        nlohmann::json stylite;
+        nlohmann::json suessiones;
+        nlohmann::json timelily;
+        nlohmann::json unprofaned;
+        nlohmann::json vorticular;
+    };
+
+    using SantirElement = std::variant<SantirClass, double>;
+
+    using Saprophilous = std::optional<std::variant<std::map<std::string, int64_t>, std::string>>;
+
+    struct SaxtenClass {
+        nlohmann::json algarrobilla;
+        nlohmann::json bowgrace;
+        std::optional<double> catharticalness;
+        nlohmann::json centaurid;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json flix;
+        nlohmann::json germanely;
+        std::optional<bool> homocerc;
+        nlohmann::json inhume;
+        nlohmann::json lepidote;
+        nlohmann::json megalochirous;
+        nlohmann::json ninepenny;
+        nlohmann::json nonbookish;
+        nlohmann::json nondeist;
+        nlohmann::json nymphaeaceous;
+        nlohmann::json parietofrontal;
+        nlohmann::json sancyite;
+        nlohmann::json subjectivist;
+        nlohmann::json tibiad;
+        nlohmann::json transonic;
+        nlohmann::json tripetalous;
+        nlohmann::json trunchman;
+        nlohmann::json urger;
+        nlohmann::json withdrawnness;
+    };
+
+    using SaxtenElement = std::variant<SaxtenClass, std::string>;
+
+    struct Scatty {
+        nlohmann::json aeriferous;
+        nlohmann::json antical;
+        nlohmann::json antighostism;
+        nlohmann::json arcanum;
+        nlohmann::json autotrophy;
+        nlohmann::json baronial;
+        nlohmann::json caffeine;
+        nlohmann::json gorgoniacean;
+        nlohmann::json heroical;
+        nlohmann::json hydropical;
+        nlohmann::json mechanology;
+        nlohmann::json musicopoetic;
+        nlohmann::json officiality;
+        nlohmann::json oftentimes;
+        nlohmann::json ophthalmotonometer;
+        nlohmann::json reflectively;
+        nlohmann::json springer;
+        nlohmann::json tabasco;
+        nlohmann::json teleianthous;
+        nlohmann::json uncombated;
+    };
+
+    using Scoffer = std::optional<std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>>>;
+
+    using Scrampum = std::optional<std::variant<std::vector<int64_t>, bool>>;
+
+    using Serpentinic = std::variant<std::vector<int64_t>, double>;
+
+    using Shadowable = std::variant<std::vector<std::optional<int64_t>>, bool>;
+
+    struct SisteringClass {
+        nlohmann::json amphicarpic;
+        nlohmann::json chianti;
+        nlohmann::json frigorific;
+        nlohmann::json haplomi;
+        nlohmann::json hyperkinesis;
+        nlohmann::json laudable;
+        nlohmann::json madwoman;
+        nlohmann::json maimedly;
+        nlohmann::json micropterygidae;
+        nlohmann::json microrhabdus;
+        nlohmann::json nondense;
+        nlohmann::json phlebemphraxis;
+        nlohmann::json redsear;
+        nlohmann::json schismatical;
+        nlohmann::json tartryl;
+        nlohmann::json unabhorred;
+        nlohmann::json undeliberateness;
+        nlohmann::json unmixable;
+        nlohmann::json untruckling;
+        nlohmann::json vineal;
+    };
+
+    using SisteringElement = std::variant<std::vector<nlohmann::json>, SisteringClass, int64_t>;
+
+    struct Staghunting {
+        std::optional<int64_t> calorimetric;
+        std::optional<int64_t> canid;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ditriglyphic;
+        std::optional<int64_t> floriferousness;
+        std::optional<int64_t> gamelike;
+        std::optional<int64_t> grig;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> interloan;
+        std::optional<int64_t> lithotomy;
+        std::optional<int64_t> loric;
+        std::optional<int64_t> membranocoriaceous;
+        std::optional<int64_t> membranogenic;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> overtrump;
+        std::optional<int64_t> scotino;
+        std::optional<int64_t> seasonable;
+        std::optional<int64_t> sephen;
+        std::optional<int64_t> stigmarioid;
+        std::optional<int64_t> tired;
+        std::optional<int64_t> trifid;
+        std::optional<int64_t> undefeatedly;
+        std::optional<int64_t> ungirlish;
+    };
+
+    using Stagmometer = std::variant<std::vector<std::optional<int64_t>>, std::string>;
+
+    using Stimulability = std::variant<bool, int64_t, std::map<std::string, int64_t>>;
+
+    using Strangleable = std::variant<std::vector<nlohmann::json>, double>;
+
+    struct StrenuosityClass {
+        std::optional<int64_t> bliss;
+        std::optional<int64_t> buccate;
+        std::optional<int64_t> bulletproof;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> crumblingness;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> engagedly;
+        std::optional<int64_t> fightable;
+        std::optional<int64_t> hoariness;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> hypopodium;
+        std::optional<int64_t> luxurist;
+        std::optional<int64_t> mechanician;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> onopordon;
+        std::optional<int64_t> podgily;
+        std::optional<int64_t> reformableness;
+        std::optional<int64_t> scatterbrains;
+        std::optional<int64_t> seminuria;
+        std::optional<int64_t> sodomite;
+        std::optional<int64_t> tramp;
+        std::optional<int64_t> undueness;
+        std::optional<int64_t> worthily;
+        std::optional<int64_t> yankeeist;
+    };
+
+    using StrenuosityElement = std::variant<std::vector<nlohmann::json>, StrenuosityClass>;
+
+    using Tabaxir = std::variant<bool, double>;
+
+    using Talpiform = std::optional<std::variant<QuebrachineClass, double>>;
+
+    using Thwack = std::variant<bool, QuebrachineClass, double>;
+
+    using Tortricine = std::variant<std::vector<std::optional<int64_t>>, QuebrachineClass>;
+
+    struct TruantcyClass {
+        nlohmann::json alfiona;
+        nlohmann::json ascaridiasis;
+        nlohmann::json bungey;
+        std::optional<double> catharticalness;
+        nlohmann::json ceroxyle;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json chorology;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enmarble;
+        nlohmann::json epeira;
+        nlohmann::json eurylaimi;
+        nlohmann::json germination;
+        nlohmann::json hallelujah;
+        std::optional<bool> homocerc;
+        nlohmann::json lev;
+        nlohmann::json mouthing;
+        nlohmann::json nonbookish;
+        nlohmann::json philliloo;
+        nlohmann::json planetal;
+        nlohmann::json poney;
+        nlohmann::json punctualist;
+        nlohmann::json returnlessly;
+        nlohmann::json skelder;
+        nlohmann::json windwaywardly;
+        nlohmann::json yuman;
+    };
+
+    using TruantcyElement = std::variant<bool, TruantcyClass>;
+
+    using Unbeginning = std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>, std::string>;
+
+    using Undesirability = std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>;
+
+    using Unerasing = std::variant<std::vector<nlohmann::json>, int64_t, std::map<std::string, int64_t>>;
+
+    using Unguentarium = std::optional<std::variant<std::vector<nlohmann::json>, int64_t>>;
+
+    struct UnimpeachablyClass {
+        std::optional<int64_t> acerin;
+        std::optional<int64_t> bobadil;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chlorophylligenous;
+        std::optional<int64_t> conversational;
+        std::optional<int64_t> demiowl;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ectorhinal;
+        std::optional<int64_t> gamblesomeness;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> irrorate;
+        std::optional<int64_t> kindergartening;
+        std::optional<int64_t> lateritic;
+        std::optional<int64_t> mespil;
+        std::optional<int64_t> misconfiguration;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> planometry;
+        std::optional<int64_t> quiina;
+        std::optional<int64_t> robert;
+        std::optional<int64_t> rot;
+        std::optional<int64_t> subcinctorium;
+        std::optional<int64_t> tussocker;
+        std::optional<int64_t> ultraproud;
+        std::optional<int64_t> unsuggestedness;
+    };
+
+    using UnimpeachablyElement = std::variant<bool, UnimpeachablyClass>;
+
+    using Unmortgaged = std::optional<std::variant<double, std::map<std::string, int64_t>>>;
+
+    using Unobstructed = std::optional<std::variant<QuebrachineClass, int64_t>>;
+
+    using Unreceptivity = std::variant<std::vector<nlohmann::json>, int64_t, std::string>;
+
+    using Unsatisfactoriness = std::variant<std::vector<int64_t>, bool, int64_t>;
+
+    struct UnstressedClass {
+        nlohmann::json alain;
+        nlohmann::json amphirhina;
+        nlohmann::json antimachinery;
+        nlohmann::json coldish;
+        nlohmann::json crantara;
+        nlohmann::json distinguishing;
+        nlohmann::json elytroposis;
+        nlohmann::json gentianwort;
+        nlohmann::json heliosis;
+        nlohmann::json instrumental;
+        nlohmann::json introinflection;
+        nlohmann::json kala;
+        nlohmann::json lincolnian;
+        nlohmann::json metad;
+        nlohmann::json sarcophilus;
+        nlohmann::json swingingly;
+        nlohmann::json unconformity;
+        nlohmann::json undecreed;
+        nlohmann::json venerable;
+        nlohmann::json vowellessness;
+    };
+
+    using UnstressedElement = std::variant<bool, UnstressedClass, std::string>;
+
+    using Untasked = std::variant<std::vector<nlohmann::json>, double, std::map<std::string, int64_t>>;
+
+    using Unvarying = std::variant<bool, double, std::map<std::string, int64_t>>;
+
+    using Vehemently = std::optional<std::variant<std::vector<nlohmann::json>, bool>>;
+
+    using Whitepot = std::variant<QuebrachineClass, double>;
+
+    struct WrothyClass {
+        nlohmann::json aeschynanthus;
+        nlohmann::json aquiferous;
+        nlohmann::json cheapener;
+        nlohmann::json enumeration;
+        nlohmann::json ephesine;
+        nlohmann::json escadrille;
+        nlohmann::json estrous;
+        nlohmann::json interestedly;
+        nlohmann::json katakinetomer;
+        nlohmann::json mortification;
+        nlohmann::json morula;
+        nlohmann::json orthosymmetrical;
+        nlohmann::json overbark;
+        nlohmann::json politist;
+        nlohmann::json qualified;
+        nlohmann::json sphenomalar;
+        nlohmann::json throatful;
+        nlohmann::json transhumance;
+        nlohmann::json triandrian;
+        nlohmann::json unbooked;
+    };
+
+    using WrothyElement = std::variant<std::vector<nlohmann::json>, WrothyClass>;
+
+    struct TopLevel {
+        std::vector<Protrusive> protrusive;
+        std::vector<PulpitismElement> pulpitism;
+        std::vector<PyodermiaElement> pyodermia;
+        std::vector<QuebrachineElement> quebrachine;
+        std::vector<Querier> querier;
+        std::vector<Rebarbative> rebarbative;
+        std::vector<Reimagine> reimagine;
+        Ressaut ressaut;
+        std::vector<Retrocervical> retrocervical;
+        std::vector<Revert> revert;
+        std::vector<RewriteElement> rewrite;
+        std::vector<Saccoderm> saccoderm;
+        std::vector<SantirElement> santir;
+        std::vector<Saprophilous> saprophilous;
+        std::vector<SaxtenElement> saxten;
+        std::vector<std::optional<Scatty>> scatty;
+        std::vector<Scoffer> scoffer;
+        std::vector<Scrampum> scrampum;
+        double semantic;
+        std::vector<Serpentinic> serpentinic;
+        std::vector<Shadowable> shadowable;
+        std::vector<SisteringElement> sistering;
+        std::vector<Staghunting> staghunting;
+        std::vector<Stagmometer> stagmometer;
+        std::vector<Stimulability> stimulability;
+        std::vector<Strangleable> strangleable;
+        std::vector<StrenuosityElement> strenuosity;
+        std::vector<Tabaxir> tabaxir;
+        std::vector<Talpiform> talpiform;
+        std::vector<Thwack> thwack;
+        std::vector<std::optional<double>> to;
+        std::vector<Tortricine> tortricine;
+        std::vector<TruantcyElement> truantcy;
+        std::vector<std::string> turgesce;
+        std::vector<Unbeginning> unbeginning;
+        std::vector<double> underdunged;
+        std::vector<Undesirability> undesirability;
+        std::vector<Unerasing> unerasing;
+        std::vector<Unguentarium> unguentarium;
+        std::vector<UnimpeachablyElement> unimpeachably;
+        std::vector<Unmortgaged> unmortgaged;
+        std::vector<Unobstructed> unobstructed;
+        std::vector<Unreceptivity> unreceptivity;
+        std::vector<Unsatisfactoriness> unsatisfactoriness;
+        std::vector<int64_t> unsecurity;
+        std::vector<UnstressedElement> unstressed;
+        std::vector<Untasked> untasked;
+        std::vector<Unvarying> unvarying;
+        std::vector<Vehemently> vehemently;
+        std::map<std::string, bool> warriorship;
+        std::vector<Whitepot> whitepot;
+        std::vector<WrothyElement> wrothy;
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, PulpitismClass & x);
+void to_json(json & j, const PulpitismClass & x);
+
+void from_json(const json & j, PyodermiaClass & x);
+void to_json(json & j, const PyodermiaClass & x);
+
+void from_json(const json & j, QuebrachineClass & x);
+void to_json(json & j, const QuebrachineClass & x);
+
+void from_json(const json & j, Reimagine & x);
+void to_json(json & j, const Reimagine & x);
+
+void from_json(const json & j, Ressaut & x);
+void to_json(json & j, const Ressaut & x);
+
+void from_json(const json & j, RewriteClass & x);
+void to_json(json & j, const RewriteClass & x);
+
+void from_json(const json & j, SantirClass & x);
+void to_json(json & j, const SantirClass & x);
+
+void from_json(const json & j, SaxtenClass & x);
+void to_json(json & j, const SaxtenClass & x);
+
+void from_json(const json & j, Scatty & x);
+void to_json(json & j, const Scatty & x);
+
+void from_json(const json & j, SisteringClass & x);
+void to_json(json & j, const SisteringClass & x);
+
+void from_json(const json & j, Staghunting & x);
+void to_json(json & j, const Staghunting & x);
+
+void from_json(const json & j, StrenuosityClass & x);
+void to_json(json & j, const StrenuosityClass & x);
+
+void from_json(const json & j, TruantcyClass & x);
+void to_json(json & j, const TruantcyClass & x);
+
+void from_json(const json & j, UnimpeachablyClass & x);
+void to_json(json & j, const UnimpeachablyClass & x);
+
+void from_json(const json & j, UnstressedClass & x);
+void to_json(json & j, const UnstressedClass & x);
+
+void from_json(const json & j, WrothyClass & x);
+void to_json(json & j, const WrothyClass & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::PyodermiaClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::PyodermiaClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::QuebrachineClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::string>> {
+    static void from_json(const json & j, std::variant<bool, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::RewriteClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SantirClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::SantirClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::SantirClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SaxtenClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::SaxtenClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::SaxtenClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::StrenuosityClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(const json & j, std::variant<bool, double> & x);
+    static void to_json(json & j, const std::variant<bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::QuebrachineClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::QuebrachineClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::QuebrachineClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass, double> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::TruantcyClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::TruantcyClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::TruantcyClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::UnimpeachablyClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::UnimpeachablyClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::QuebrachineClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::QuebrachineClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::UnstressedClass, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::UnstressedClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::WrothyClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::WrothyClass> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, PulpitismClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.abnet = get_untyped(j, "abnet");
+        x.buckhorn = get_untyped(j, "buckhorn");
+        x.calciform = get_untyped(j, "calciform");
+        x.chelophore = get_untyped(j, "chelophore");
+        x.cogitation = get_untyped(j, "cogitation");
+        x.decreeable = get_untyped(j, "decreeable");
+        x.despicable = get_untyped(j, "despicable");
+        x.isodiazo = get_untyped(j, "isodiazo");
+        x.jadedly = get_untyped(j, "jadedly");
+        x.leptochlorite = get_untyped(j, "leptochlorite");
+        x.nursling = get_untyped(j, "nursling");
+        x.palamedean = get_untyped(j, "palamedean");
+        x.photoheliograph = get_untyped(j, "photoheliograph");
+        x.pipewood = get_untyped(j, "pipewood");
+        x.roberd = get_untyped(j, "roberd");
+        x.statable = get_untyped(j, "statable");
+        x.superassume = get_untyped(j, "superassume");
+        x.syllabe = get_untyped(j, "syllabe");
+        x.toughhead = get_untyped(j, "toughhead");
+        x.underburn = get_untyped(j, "underburn");
+    }
+
+    inline void to_json(json & j, const PulpitismClass & x) {
+        j = json::object();
+        j["abnet"] = x.abnet;
+        j["buckhorn"] = x.buckhorn;
+        j["calciform"] = x.calciform;
+        j["chelophore"] = x.chelophore;
+        j["cogitation"] = x.cogitation;
+        j["decreeable"] = x.decreeable;
+        j["despicable"] = x.despicable;
+        j["isodiazo"] = x.isodiazo;
+        j["jadedly"] = x.jadedly;
+        j["leptochlorite"] = x.leptochlorite;
+        j["nursling"] = x.nursling;
+        j["palamedean"] = x.palamedean;
+        j["photoheliograph"] = x.photoheliograph;
+        j["pipewood"] = x.pipewood;
+        j["roberd"] = x.roberd;
+        j["statable"] = x.statable;
+        j["superassume"] = x.superassume;
+        j["syllabe"] = x.syllabe;
+        j["toughhead"] = x.toughhead;
+        j["underburn"] = x.underburn;
+    }
+
+    inline void from_json(const json & j, PyodermiaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.aphoristically = get_untyped(j, "aphoristically");
+        x.apophyllous = get_untyped(j, "apophyllous");
+        x.cognize = get_untyped(j, "cognize");
+        x.dermonosology = get_untyped(j, "dermonosology");
+        x.gyppo = get_untyped(j, "Gyppo");
+        x.ither = get_untyped(j, "ither");
+        x.juglandaceous = get_untyped(j, "juglandaceous");
+        x.litho = get_untyped(j, "litho");
+        x.macropterous = get_untyped(j, "macropterous");
+        x.photographer = get_untyped(j, "photographer");
+        x.romancing = get_untyped(j, "romancing");
+        x.rumness = get_untyped(j, "rumness");
+        x.somniloquist = get_untyped(j, "somniloquist");
+        x.stressfully = get_untyped(j, "stressfully");
+        x.tactically = get_untyped(j, "tactically");
+        x.tracheophony = get_untyped(j, "tracheophony");
+        x.unappositely = get_untyped(j, "unappositely");
+        x.unclothedly = get_untyped(j, "unclothedly");
+        x.unimplied = get_untyped(j, "unimplied");
+        x.unsyncopated = get_untyped(j, "unsyncopated");
+    }
+
+    inline void to_json(json & j, const PyodermiaClass & x) {
+        j = json::object();
+        j["aphoristically"] = x.aphoristically;
+        j["apophyllous"] = x.apophyllous;
+        j["cognize"] = x.cognize;
+        j["dermonosology"] = x.dermonosology;
+        j["Gyppo"] = x.gyppo;
+        j["ither"] = x.ither;
+        j["juglandaceous"] = x.juglandaceous;
+        j["litho"] = x.litho;
+        j["macropterous"] = x.macropterous;
+        j["photographer"] = x.photographer;
+        j["romancing"] = x.romancing;
+        j["rumness"] = x.rumness;
+        j["somniloquist"] = x.somniloquist;
+        j["stressfully"] = x.stressfully;
+        j["tactically"] = x.tactically;
+        j["tracheophony"] = x.tracheophony;
+        j["unappositely"] = x.unappositely;
+        j["unclothedly"] = x.unclothedly;
+        j["unimplied"] = x.unimplied;
+        j["unsyncopated"] = x.unsyncopated;
+    }
+
+    inline void from_json(const json & j, QuebrachineClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.catharticalness = j.at("catharticalness").get<double>();
+        x.chirotherium = j.at("Chirotherium").get<int64_t>();
+        x.disdiapason = j.at("disdiapason").get<std::string>();
+        x.homocerc = j.at("homocerc").get<bool>();
+        x.nonbookish = get_untyped(j, "nonbookish");
+    }
+
+    inline void to_json(json & j, const QuebrachineClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["homocerc"] = x.homocerc;
+        j["nonbookish"] = x.nonbookish;
+    }
+
+    inline void from_json(const json & j, Reimagine& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.adducible = get_untyped(j, "adducible");
+        x.anabolin = get_untyped(j, "anabolin");
+        x.brainy = get_untyped(j, "brainy");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.chrysamine = get_untyped(j, "chrysamine");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.fluxweed = get_untyped(j, "fluxweed");
+        x.glaucine = get_untyped(j, "glaucine");
+        x.grobianism = get_untyped(j, "grobianism");
+        x.hermo = get_untyped(j, "Hermo");
+        x.hieroglyphist = get_untyped(j, "hieroglyphist");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.icteroid = get_untyped(j, "icteroid");
+        x.immortal = get_untyped(j, "immortal");
+        x.impetulant = get_untyped(j, "impetulant");
+        x.irrigate = get_untyped(j, "irrigate");
+        x.myxedema = get_untyped(j, "myxedema");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.onyx = get_untyped(j, "onyx");
+        x.repasser = get_untyped(j, "repasser");
+        x.septomarginal = get_untyped(j, "septomarginal");
+        x.subdie = get_untyped(j, "subdie");
+        x.tibiometatarsal = get_untyped(j, "tibiometatarsal");
+        x.waltzlike = get_untyped(j, "waltzlike");
+    }
+
+    inline void to_json(json & j, const Reimagine & x) {
+        j = json::object();
+        j["adducible"] = x.adducible;
+        j["anabolin"] = x.anabolin;
+        j["brainy"] = x.brainy;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["chrysamine"] = x.chrysamine;
+        j["disdiapason"] = x.disdiapason;
+        j["fluxweed"] = x.fluxweed;
+        j["glaucine"] = x.glaucine;
+        j["grobianism"] = x.grobianism;
+        j["Hermo"] = x.hermo;
+        j["hieroglyphist"] = x.hieroglyphist;
+        j["homocerc"] = x.homocerc;
+        j["icteroid"] = x.icteroid;
+        j["immortal"] = x.immortal;
+        j["impetulant"] = x.impetulant;
+        j["irrigate"] = x.irrigate;
+        j["myxedema"] = x.myxedema;
+        j["nonbookish"] = x.nonbookish;
+        j["onyx"] = x.onyx;
+        j["repasser"] = x.repasser;
+        j["septomarginal"] = x.septomarginal;
+        j["subdie"] = x.subdie;
+        j["tibiometatarsal"] = x.tibiometatarsal;
+        j["waltzlike"] = x.waltzlike;
+    }
+
+    inline void from_json(const json & j, Ressaut& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.apperceptive = j.at("apperceptive").get<std::string>();
+        x.cuttoo = j.at("cuttoo").get<std::string>();
+        x.douser = j.at("douser").get<std::string>();
+        x.drinkproof = j.at("drinkproof").get<std::string>();
+        x.forementioned = j.at("forementioned").get<std::string>();
+        x.freesia = j.at("Freesia").get<std::string>();
+        x.genevieve = j.at("Genevieve").get<std::string>();
+        x.hyperdiabolical = j.at("hyperdiabolical").get<std::string>();
+        x.hypocone = j.at("hypocone").get<std::string>();
+        x.irreverentially = j.at("irreverentially").get<std::string>();
+        x.jumart = j.at("jumart").get<std::string>();
+        x.mimosaceae = j.at("Mimosaceae").get<std::string>();
+        x.mollicrush = j.at("mollicrush").get<std::string>();
+        x.nedder = j.at("nedder").get<std::string>();
+        x.retinasphalt = j.at("retinasphalt").get<std::string>();
+        x.sough = j.at("sough").get<std::string>();
+        x.steading = j.at("steading").get<std::string>();
+        x.theopaschitism = j.at("Theopaschitism").get<std::string>();
+        x.undurableness = j.at("undurableness").get<std::string>();
+        x.unmingleable = j.at("unmingleable").get<std::string>();
+    }
+
+    inline void to_json(json & j, const Ressaut & x) {
+        j = json::object();
+        j["apperceptive"] = x.apperceptive;
+        j["cuttoo"] = x.cuttoo;
+        j["douser"] = x.douser;
+        j["drinkproof"] = x.drinkproof;
+        j["forementioned"] = x.forementioned;
+        j["Freesia"] = x.freesia;
+        j["Genevieve"] = x.genevieve;
+        j["hyperdiabolical"] = x.hyperdiabolical;
+        j["hypocone"] = x.hypocone;
+        j["irreverentially"] = x.irreverentially;
+        j["jumart"] = x.jumart;
+        j["Mimosaceae"] = x.mimosaceae;
+        j["mollicrush"] = x.mollicrush;
+        j["nedder"] = x.nedder;
+        j["retinasphalt"] = x.retinasphalt;
+        j["sough"] = x.sough;
+        j["steading"] = x.steading;
+        j["Theopaschitism"] = x.theopaschitism;
+        j["undurableness"] = x.undurableness;
+        j["unmingleable"] = x.unmingleable;
+    }
+
+    inline void from_json(const json & j, RewriteClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.accountancy = get_untyped(j, "accountancy");
+        x.cacotrophic = get_untyped(j, "cacotrophic");
+        x.contest = get_untyped(j, "contest");
+        x.couthily = get_untyped(j, "couthily");
+        x.falculate = get_untyped(j, "falculate");
+        x.foreseize = get_untyped(j, "foreseize");
+        x.hyades = get_untyped(j, "Hyades");
+        x.lemnad = get_untyped(j, "lemnad");
+        x.monotheistically = get_untyped(j, "monotheistically");
+        x.nonflying = get_untyped(j, "nonflying");
+        x.ptenoglossa = get_untyped(j, "Ptenoglossa");
+        x.repatch = get_untyped(j, "repatch");
+        x.rodman = get_untyped(j, "rodman");
+        x.strung = get_untyped(j, "strung");
+        x.titmal = get_untyped(j, "titmal");
+        x.twalpennyworth = get_untyped(j, "twalpennyworth");
+        x.unblamable = get_untyped(j, "unblamable");
+        x.vertical = get_untyped(j, "vertical");
+        x.whiggification = get_untyped(j, "Whiggification");
+        x.yardman = get_untyped(j, "yardman");
+    }
+
+    inline void to_json(json & j, const RewriteClass & x) {
+        j = json::object();
+        j["accountancy"] = x.accountancy;
+        j["cacotrophic"] = x.cacotrophic;
+        j["contest"] = x.contest;
+        j["couthily"] = x.couthily;
+        j["falculate"] = x.falculate;
+        j["foreseize"] = x.foreseize;
+        j["Hyades"] = x.hyades;
+        j["lemnad"] = x.lemnad;
+        j["monotheistically"] = x.monotheistically;
+        j["nonflying"] = x.nonflying;
+        j["Ptenoglossa"] = x.ptenoglossa;
+        j["repatch"] = x.repatch;
+        j["rodman"] = x.rodman;
+        j["strung"] = x.strung;
+        j["titmal"] = x.titmal;
+        j["twalpennyworth"] = x.twalpennyworth;
+        j["unblamable"] = x.unblamable;
+        j["vertical"] = x.vertical;
+        j["Whiggification"] = x.whiggification;
+        j["yardman"] = x.yardman;
+    }
+
+    inline void from_json(const json & j, SantirClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.admiredly = get_untyped(j, "admiredly");
+        x.demicaponier = get_untyped(j, "demicaponier");
+        x.epitympanic = get_untyped(j, "epitympanic");
+        x.investitor = get_untyped(j, "investitor");
+        x.lupiform = get_untyped(j, "lupiform");
+        x.monoflagellate = get_untyped(j, "monoflagellate");
+        x.paleoethnic = get_untyped(j, "paleoethnic");
+        x.prediscountable = get_untyped(j, "prediscountable");
+        x.rhetoricals = get_untyped(j, "rhetoricals");
+        x.roomth = get_untyped(j, "roomth");
+        x.saccharose = get_untyped(j, "saccharose");
+        x.septonasal = get_untyped(j, "septonasal");
+        x.serpenticide = get_untyped(j, "serpenticide");
+        x.setarious = get_untyped(j, "setarious");
+        x.spaework = get_untyped(j, "spaework");
+        x.stylite = get_untyped(j, "stylite");
+        x.suessiones = get_untyped(j, "Suessiones");
+        x.timelily = get_untyped(j, "timelily");
+        x.unprofaned = get_untyped(j, "unprofaned");
+        x.vorticular = get_untyped(j, "vorticular");
+    }
+
+    inline void to_json(json & j, const SantirClass & x) {
+        j = json::object();
+        j["admiredly"] = x.admiredly;
+        j["demicaponier"] = x.demicaponier;
+        j["epitympanic"] = x.epitympanic;
+        j["investitor"] = x.investitor;
+        j["lupiform"] = x.lupiform;
+        j["monoflagellate"] = x.monoflagellate;
+        j["paleoethnic"] = x.paleoethnic;
+        j["prediscountable"] = x.prediscountable;
+        j["rhetoricals"] = x.rhetoricals;
+        j["roomth"] = x.roomth;
+        j["saccharose"] = x.saccharose;
+        j["septonasal"] = x.septonasal;
+        j["serpenticide"] = x.serpenticide;
+        j["setarious"] = x.setarious;
+        j["spaework"] = x.spaework;
+        j["stylite"] = x.stylite;
+        j["Suessiones"] = x.suessiones;
+        j["timelily"] = x.timelily;
+        j["unprofaned"] = x.unprofaned;
+        j["vorticular"] = x.vorticular;
+    }
+
+    inline void from_json(const json & j, SaxtenClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.algarrobilla = get_untyped(j, "algarrobilla");
+        x.bowgrace = get_untyped(j, "bowgrace");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.centaurid = get_untyped(j, "Centaurid");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.flix = get_untyped(j, "flix");
+        x.germanely = get_untyped(j, "germanely");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.inhume = get_untyped(j, "inhume");
+        x.lepidote = get_untyped(j, "lepidote");
+        x.megalochirous = get_untyped(j, "megalochirous");
+        x.ninepenny = get_untyped(j, "ninepenny");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.nondeist = get_untyped(j, "nondeist");
+        x.nymphaeaceous = get_untyped(j, "nymphaeaceous");
+        x.parietofrontal = get_untyped(j, "parietofrontal");
+        x.sancyite = get_untyped(j, "sancyite");
+        x.subjectivist = get_untyped(j, "subjectivist");
+        x.tibiad = get_untyped(j, "tibiad");
+        x.transonic = get_untyped(j, "transonic");
+        x.tripetalous = get_untyped(j, "tripetalous");
+        x.trunchman = get_untyped(j, "trunchman");
+        x.urger = get_untyped(j, "urger");
+        x.withdrawnness = get_untyped(j, "withdrawnness");
+    }
+
+    inline void to_json(json & j, const SaxtenClass & x) {
+        j = json::object();
+        j["algarrobilla"] = x.algarrobilla;
+        j["bowgrace"] = x.bowgrace;
+        j["catharticalness"] = x.catharticalness;
+        j["Centaurid"] = x.centaurid;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["flix"] = x.flix;
+        j["germanely"] = x.germanely;
+        j["homocerc"] = x.homocerc;
+        j["inhume"] = x.inhume;
+        j["lepidote"] = x.lepidote;
+        j["megalochirous"] = x.megalochirous;
+        j["ninepenny"] = x.ninepenny;
+        j["nonbookish"] = x.nonbookish;
+        j["nondeist"] = x.nondeist;
+        j["nymphaeaceous"] = x.nymphaeaceous;
+        j["parietofrontal"] = x.parietofrontal;
+        j["sancyite"] = x.sancyite;
+        j["subjectivist"] = x.subjectivist;
+        j["tibiad"] = x.tibiad;
+        j["transonic"] = x.transonic;
+        j["tripetalous"] = x.tripetalous;
+        j["trunchman"] = x.trunchman;
+        j["urger"] = x.urger;
+        j["withdrawnness"] = x.withdrawnness;
+    }
+
+    inline void from_json(const json & j, Scatty& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.aeriferous = get_untyped(j, "aeriferous");
+        x.antical = get_untyped(j, "antical");
+        x.antighostism = get_untyped(j, "antighostism");
+        x.arcanum = get_untyped(j, "arcanum");
+        x.autotrophy = get_untyped(j, "autotrophy");
+        x.baronial = get_untyped(j, "baronial");
+        x.caffeine = get_untyped(j, "caffeine");
+        x.gorgoniacean = get_untyped(j, "gorgoniacean");
+        x.heroical = get_untyped(j, "heroical");
+        x.hydropical = get_untyped(j, "hydropical");
+        x.mechanology = get_untyped(j, "mechanology");
+        x.musicopoetic = get_untyped(j, "musicopoetic");
+        x.officiality = get_untyped(j, "officiality");
+        x.oftentimes = get_untyped(j, "oftentimes");
+        x.ophthalmotonometer = get_untyped(j, "ophthalmotonometer");
+        x.reflectively = get_untyped(j, "reflectively");
+        x.springer = get_untyped(j, "springer");
+        x.tabasco = get_untyped(j, "Tabasco");
+        x.teleianthous = get_untyped(j, "teleianthous");
+        x.uncombated = get_untyped(j, "uncombated");
+    }
+
+    inline void to_json(json & j, const Scatty & x) {
+        j = json::object();
+        j["aeriferous"] = x.aeriferous;
+        j["antical"] = x.antical;
+        j["antighostism"] = x.antighostism;
+        j["arcanum"] = x.arcanum;
+        j["autotrophy"] = x.autotrophy;
+        j["baronial"] = x.baronial;
+        j["caffeine"] = x.caffeine;
+        j["gorgoniacean"] = x.gorgoniacean;
+        j["heroical"] = x.heroical;
+        j["hydropical"] = x.hydropical;
+        j["mechanology"] = x.mechanology;
+        j["musicopoetic"] = x.musicopoetic;
+        j["officiality"] = x.officiality;
+        j["oftentimes"] = x.oftentimes;
+        j["ophthalmotonometer"] = x.ophthalmotonometer;
+        j["reflectively"] = x.reflectively;
+        j["springer"] = x.springer;
+        j["Tabasco"] = x.tabasco;
+        j["teleianthous"] = x.teleianthous;
+        j["uncombated"] = x.uncombated;
+    }
+
+    inline void from_json(const json & j, SisteringClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.amphicarpic = get_untyped(j, "amphicarpic");
+        x.chianti = get_untyped(j, "Chianti");
+        x.frigorific = get_untyped(j, "frigorific");
+        x.haplomi = get_untyped(j, "Haplomi");
+        x.hyperkinesis = get_untyped(j, "hyperkinesis");
+        x.laudable = get_untyped(j, "laudable");
+        x.madwoman = get_untyped(j, "madwoman");
+        x.maimedly = get_untyped(j, "maimedly");
+        x.micropterygidae = get_untyped(j, "Micropterygidae");
+        x.microrhabdus = get_untyped(j, "microrhabdus");
+        x.nondense = get_untyped(j, "nondense");
+        x.phlebemphraxis = get_untyped(j, "phlebemphraxis");
+        x.redsear = get_untyped(j, "redsear");
+        x.schismatical = get_untyped(j, "schismatical");
+        x.tartryl = get_untyped(j, "tartryl");
+        x.unabhorred = get_untyped(j, "unabhorred");
+        x.undeliberateness = get_untyped(j, "undeliberateness");
+        x.unmixable = get_untyped(j, "unmixable");
+        x.untruckling = get_untyped(j, "untruckling");
+        x.vineal = get_untyped(j, "vineal");
+    }
+
+    inline void to_json(json & j, const SisteringClass & x) {
+        j = json::object();
+        j["amphicarpic"] = x.amphicarpic;
+        j["Chianti"] = x.chianti;
+        j["frigorific"] = x.frigorific;
+        j["Haplomi"] = x.haplomi;
+        j["hyperkinesis"] = x.hyperkinesis;
+        j["laudable"] = x.laudable;
+        j["madwoman"] = x.madwoman;
+        j["maimedly"] = x.maimedly;
+        j["Micropterygidae"] = x.micropterygidae;
+        j["microrhabdus"] = x.microrhabdus;
+        j["nondense"] = x.nondense;
+        j["phlebemphraxis"] = x.phlebemphraxis;
+        j["redsear"] = x.redsear;
+        j["schismatical"] = x.schismatical;
+        j["tartryl"] = x.tartryl;
+        j["unabhorred"] = x.unabhorred;
+        j["undeliberateness"] = x.undeliberateness;
+        j["unmixable"] = x.unmixable;
+        j["untruckling"] = x.untruckling;
+        j["vineal"] = x.vineal;
+    }
+
+    inline void from_json(const json & j, Staghunting& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.calorimetric = get_stack_optional<int64_t>(j, "calorimetric");
+        x.canid = get_stack_optional<int64_t>(j, "canid");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.ditriglyphic = get_stack_optional<int64_t>(j, "ditriglyphic");
+        x.floriferousness = get_stack_optional<int64_t>(j, "floriferousness");
+        x.gamelike = get_stack_optional<int64_t>(j, "gamelike");
+        x.grig = get_stack_optional<int64_t>(j, "grig");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.interloan = get_stack_optional<int64_t>(j, "interloan");
+        x.lithotomy = get_stack_optional<int64_t>(j, "lithotomy");
+        x.loric = get_stack_optional<int64_t>(j, "loric");
+        x.membranocoriaceous = get_stack_optional<int64_t>(j, "membranocoriaceous");
+        x.membranogenic = get_stack_optional<int64_t>(j, "membranogenic");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.overtrump = get_stack_optional<int64_t>(j, "overtrump");
+        x.scotino = get_stack_optional<int64_t>(j, "scotino");
+        x.seasonable = get_stack_optional<int64_t>(j, "seasonable");
+        x.sephen = get_stack_optional<int64_t>(j, "sephen");
+        x.stigmarioid = get_stack_optional<int64_t>(j, "stigmarioid");
+        x.tired = get_stack_optional<int64_t>(j, "tired");
+        x.trifid = get_stack_optional<int64_t>(j, "trifid");
+        x.undefeatedly = get_stack_optional<int64_t>(j, "undefeatedly");
+        x.ungirlish = get_stack_optional<int64_t>(j, "ungirlish");
+    }
+
+    inline void to_json(json & j, const Staghunting & x) {
+        j = json::object();
+        j["calorimetric"] = x.calorimetric;
+        j["canid"] = x.canid;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["disdiapason"] = x.disdiapason;
+        j["ditriglyphic"] = x.ditriglyphic;
+        j["floriferousness"] = x.floriferousness;
+        j["gamelike"] = x.gamelike;
+        j["grig"] = x.grig;
+        j["homocerc"] = x.homocerc;
+        j["interloan"] = x.interloan;
+        j["lithotomy"] = x.lithotomy;
+        j["loric"] = x.loric;
+        j["membranocoriaceous"] = x.membranocoriaceous;
+        j["membranogenic"] = x.membranogenic;
+        j["nonbookish"] = x.nonbookish;
+        j["overtrump"] = x.overtrump;
+        j["scotino"] = x.scotino;
+        j["seasonable"] = x.seasonable;
+        j["sephen"] = x.sephen;
+        j["stigmarioid"] = x.stigmarioid;
+        j["tired"] = x.tired;
+        j["trifid"] = x.trifid;
+        j["undefeatedly"] = x.undefeatedly;
+        j["ungirlish"] = x.ungirlish;
+    }
+
+    inline void from_json(const json & j, StrenuosityClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.bliss = get_stack_optional<int64_t>(j, "bliss");
+        x.buccate = get_stack_optional<int64_t>(j, "buccate");
+        x.bulletproof = get_stack_optional<int64_t>(j, "bulletproof");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.crumblingness = get_stack_optional<int64_t>(j, "crumblingness");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.engagedly = get_stack_optional<int64_t>(j, "engagedly");
+        x.fightable = get_stack_optional<int64_t>(j, "fightable");
+        x.hoariness = get_stack_optional<int64_t>(j, "hoariness");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.hypopodium = get_stack_optional<int64_t>(j, "hypopodium");
+        x.luxurist = get_stack_optional<int64_t>(j, "luxurist");
+        x.mechanician = get_stack_optional<int64_t>(j, "mechanician");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.onopordon = get_stack_optional<int64_t>(j, "Onopordon");
+        x.podgily = get_stack_optional<int64_t>(j, "podgily");
+        x.reformableness = get_stack_optional<int64_t>(j, "reformableness");
+        x.scatterbrains = get_stack_optional<int64_t>(j, "scatterbrains");
+        x.seminuria = get_stack_optional<int64_t>(j, "seminuria");
+        x.sodomite = get_stack_optional<int64_t>(j, "Sodomite");
+        x.tramp = get_stack_optional<int64_t>(j, "tramp");
+        x.undueness = get_stack_optional<int64_t>(j, "undueness");
+        x.worthily = get_stack_optional<int64_t>(j, "worthily");
+        x.yankeeist = get_stack_optional<int64_t>(j, "Yankeeist");
+    }
+
+    inline void to_json(json & j, const StrenuosityClass & x) {
+        j = json::object();
+        j["bliss"] = x.bliss;
+        j["buccate"] = x.buccate;
+        j["bulletproof"] = x.bulletproof;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["crumblingness"] = x.crumblingness;
+        j["disdiapason"] = x.disdiapason;
+        j["engagedly"] = x.engagedly;
+        j["fightable"] = x.fightable;
+        j["hoariness"] = x.hoariness;
+        j["homocerc"] = x.homocerc;
+        j["hypopodium"] = x.hypopodium;
+        j["luxurist"] = x.luxurist;
+        j["mechanician"] = x.mechanician;
+        j["nonbookish"] = x.nonbookish;
+        j["Onopordon"] = x.onopordon;
+        j["podgily"] = x.podgily;
+        j["reformableness"] = x.reformableness;
+        j["scatterbrains"] = x.scatterbrains;
+        j["seminuria"] = x.seminuria;
+        j["Sodomite"] = x.sodomite;
+        j["tramp"] = x.tramp;
+        j["undueness"] = x.undueness;
+        j["worthily"] = x.worthily;
+        j["Yankeeist"] = x.yankeeist;
+    }
+
+    inline void from_json(const json & j, TruantcyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.alfiona = get_untyped(j, "alfiona");
+        x.ascaridiasis = get_untyped(j, "ascaridiasis");
+        x.bungey = get_untyped(j, "bungey");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.ceroxyle = get_untyped(j, "ceroxyle");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.chorology = get_untyped(j, "chorology");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.enmarble = get_untyped(j, "enmarble");
+        x.epeira = get_untyped(j, "Epeira");
+        x.eurylaimi = get_untyped(j, "Eurylaimi");
+        x.germination = get_untyped(j, "germination");
+        x.hallelujah = get_untyped(j, "hallelujah");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.lev = get_untyped(j, "lev");
+        x.mouthing = get_untyped(j, "mouthing");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.philliloo = get_untyped(j, "philliloo");
+        x.planetal = get_untyped(j, "planetal");
+        x.poney = get_untyped(j, "poney");
+        x.punctualist = get_untyped(j, "punctualist");
+        x.returnlessly = get_untyped(j, "returnlessly");
+        x.skelder = get_untyped(j, "skelder");
+        x.windwaywardly = get_untyped(j, "windwaywardly");
+        x.yuman = get_untyped(j, "Yuman");
+    }
+
+    inline void to_json(json & j, const TruantcyClass & x) {
+        j = json::object();
+        j["alfiona"] = x.alfiona;
+        j["ascaridiasis"] = x.ascaridiasis;
+        j["bungey"] = x.bungey;
+        j["catharticalness"] = x.catharticalness;
+        j["ceroxyle"] = x.ceroxyle;
+        j["Chirotherium"] = x.chirotherium;
+        j["chorology"] = x.chorology;
+        j["disdiapason"] = x.disdiapason;
+        j["enmarble"] = x.enmarble;
+        j["Epeira"] = x.epeira;
+        j["Eurylaimi"] = x.eurylaimi;
+        j["germination"] = x.germination;
+        j["hallelujah"] = x.hallelujah;
+        j["homocerc"] = x.homocerc;
+        j["lev"] = x.lev;
+        j["mouthing"] = x.mouthing;
+        j["nonbookish"] = x.nonbookish;
+        j["philliloo"] = x.philliloo;
+        j["planetal"] = x.planetal;
+        j["poney"] = x.poney;
+        j["punctualist"] = x.punctualist;
+        j["returnlessly"] = x.returnlessly;
+        j["skelder"] = x.skelder;
+        j["windwaywardly"] = x.windwaywardly;
+        j["Yuman"] = x.yuman;
+    }
+
+    inline void from_json(const json & j, UnimpeachablyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.acerin = get_stack_optional<int64_t>(j, "acerin");
+        x.bobadil = get_stack_optional<int64_t>(j, "Bobadil");
+        x.catharticalness = get_stack_optional<double>(j, "catharticalness");
+        x.chirotherium = get_stack_optional<int64_t>(j, "Chirotherium");
+        x.chlorophylligenous = get_stack_optional<int64_t>(j, "chlorophylligenous");
+        x.conversational = get_stack_optional<int64_t>(j, "conversational");
+        x.demiowl = get_stack_optional<int64_t>(j, "demiowl");
+        x.disdiapason = get_stack_optional<std::string>(j, "disdiapason");
+        x.ectorhinal = get_stack_optional<int64_t>(j, "ectorhinal");
+        x.gamblesomeness = get_stack_optional<int64_t>(j, "gamblesomeness");
+        x.homocerc = get_stack_optional<bool>(j, "homocerc");
+        x.irrorate = get_stack_optional<int64_t>(j, "irrorate");
+        x.kindergartening = get_stack_optional<int64_t>(j, "kindergartening");
+        x.lateritic = get_stack_optional<int64_t>(j, "lateritic");
+        x.mespil = get_stack_optional<int64_t>(j, "mespil");
+        x.misconfiguration = get_stack_optional<int64_t>(j, "misconfiguration");
+        x.nonbookish = get_untyped(j, "nonbookish");
+        x.planometry = get_stack_optional<int64_t>(j, "planometry");
+        x.quiina = get_stack_optional<int64_t>(j, "Quiina");
+        x.robert = get_stack_optional<int64_t>(j, "Robert");
+        x.rot = get_stack_optional<int64_t>(j, "rot");
+        x.subcinctorium = get_stack_optional<int64_t>(j, "subcinctorium");
+        x.tussocker = get_stack_optional<int64_t>(j, "tussocker");
+        x.ultraproud = get_stack_optional<int64_t>(j, "ultraproud");
+        x.unsuggestedness = get_stack_optional<int64_t>(j, "unsuggestedness");
+    }
+
+    inline void to_json(json & j, const UnimpeachablyClass & x) {
+        j = json::object();
+        j["acerin"] = x.acerin;
+        j["Bobadil"] = x.bobadil;
+        j["catharticalness"] = x.catharticalness;
+        j["Chirotherium"] = x.chirotherium;
+        j["chlorophylligenous"] = x.chlorophylligenous;
+        j["conversational"] = x.conversational;
+        j["demiowl"] = x.demiowl;
+        j["disdiapason"] = x.disdiapason;
+        j["ectorhinal"] = x.ectorhinal;
+        j["gamblesomeness"] = x.gamblesomeness;
+        j["homocerc"] = x.homocerc;
+        j["irrorate"] = x.irrorate;
+        j["kindergartening"] = x.kindergartening;
+        j["lateritic"] = x.lateritic;
+        j["mespil"] = x.mespil;
+        j["misconfiguration"] = x.misconfiguration;
+        j["nonbookish"] = x.nonbookish;
+        j["planometry"] = x.planometry;
+        j["Quiina"] = x.quiina;
+        j["Robert"] = x.robert;
+        j["rot"] = x.rot;
+        j["subcinctorium"] = x.subcinctorium;
+        j["tussocker"] = x.tussocker;
+        j["ultraproud"] = x.ultraproud;
+        j["unsuggestedness"] = x.unsuggestedness;
+    }
+
+    inline void from_json(const json & j, UnstressedClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.alain = get_untyped(j, "Alain");
+        x.amphirhina = get_untyped(j, "Amphirhina");
+        x.antimachinery = get_untyped(j, "antimachinery");
+        x.coldish = get_untyped(j, "coldish");
+        x.crantara = get_untyped(j, "crantara");
+        x.distinguishing = get_untyped(j, "distinguishing");
+        x.elytroposis = get_untyped(j, "elytroposis");
+        x.gentianwort = get_untyped(j, "gentianwort");
+        x.heliosis = get_untyped(j, "heliosis");
+        x.instrumental = get_untyped(j, "instrumental");
+        x.introinflection = get_untyped(j, "introinflection");
+        x.kala = get_untyped(j, "kala");
+        x.lincolnian = get_untyped(j, "Lincolnian");
+        x.metad = get_untyped(j, "metad");
+        x.sarcophilus = get_untyped(j, "Sarcophilus");
+        x.swingingly = get_untyped(j, "swingingly");
+        x.unconformity = get_untyped(j, "unconformity");
+        x.undecreed = get_untyped(j, "undecreed");
+        x.venerable = get_untyped(j, "venerable");
+        x.vowellessness = get_untyped(j, "vowellessness");
+    }
+
+    inline void to_json(json & j, const UnstressedClass & x) {
+        j = json::object();
+        j["Alain"] = x.alain;
+        j["Amphirhina"] = x.amphirhina;
+        j["antimachinery"] = x.antimachinery;
+        j["coldish"] = x.coldish;
+        j["crantara"] = x.crantara;
+        j["distinguishing"] = x.distinguishing;
+        j["elytroposis"] = x.elytroposis;
+        j["gentianwort"] = x.gentianwort;
+        j["heliosis"] = x.heliosis;
+        j["instrumental"] = x.instrumental;
+        j["introinflection"] = x.introinflection;
+        j["kala"] = x.kala;
+        j["Lincolnian"] = x.lincolnian;
+        j["metad"] = x.metad;
+        j["Sarcophilus"] = x.sarcophilus;
+        j["swingingly"] = x.swingingly;
+        j["unconformity"] = x.unconformity;
+        j["undecreed"] = x.undecreed;
+        j["venerable"] = x.venerable;
+        j["vowellessness"] = x.vowellessness;
+    }
+
+    inline void from_json(const json & j, WrothyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.aeschynanthus = get_untyped(j, "Aeschynanthus");
+        x.aquiferous = get_untyped(j, "aquiferous");
+        x.cheapener = get_untyped(j, "cheapener");
+        x.enumeration = get_untyped(j, "enumeration");
+        x.ephesine = get_untyped(j, "Ephesine");
+        x.escadrille = get_untyped(j, "escadrille");
+        x.estrous = get_untyped(j, "estrous");
+        x.interestedly = get_untyped(j, "interestedly");
+        x.katakinetomer = get_untyped(j, "katakinetomer");
+        x.mortification = get_untyped(j, "mortification");
+        x.morula = get_untyped(j, "morula");
+        x.orthosymmetrical = get_untyped(j, "orthosymmetrical");
+        x.overbark = get_untyped(j, "overbark");
+        x.politist = get_untyped(j, "politist");
+        x.qualified = get_untyped(j, "qualified");
+        x.sphenomalar = get_untyped(j, "sphenomalar");
+        x.throatful = get_untyped(j, "throatful");
+        x.transhumance = get_untyped(j, "transhumance");
+        x.triandrian = get_untyped(j, "triandrian");
+        x.unbooked = get_untyped(j, "unbooked");
+    }
+
+    inline void to_json(json & j, const WrothyClass & x) {
+        j = json::object();
+        j["Aeschynanthus"] = x.aeschynanthus;
+        j["aquiferous"] = x.aquiferous;
+        j["cheapener"] = x.cheapener;
+        j["enumeration"] = x.enumeration;
+        j["Ephesine"] = x.ephesine;
+        j["escadrille"] = x.escadrille;
+        j["estrous"] = x.estrous;
+        j["interestedly"] = x.interestedly;
+        j["katakinetomer"] = x.katakinetomer;
+        j["mortification"] = x.mortification;
+        j["morula"] = x.morula;
+        j["orthosymmetrical"] = x.orthosymmetrical;
+        j["overbark"] = x.overbark;
+        j["politist"] = x.politist;
+        j["qualified"] = x.qualified;
+        j["sphenomalar"] = x.sphenomalar;
+        j["throatful"] = x.throatful;
+        j["transhumance"] = x.transhumance;
+        j["triandrian"] = x.triandrian;
+        j["unbooked"] = x.unbooked;
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.protrusive = j.at("protrusive").get<std::vector<Protrusive>>();
+        x.pulpitism = j.at("pulpitism").get<std::vector<PulpitismElement>>();
+        x.pyodermia = j.at("pyodermia").get<std::vector<PyodermiaElement>>();
+        x.quebrachine = j.at("quebrachine").get<std::vector<QuebrachineElement>>();
+        x.querier = j.at("querier").get<std::vector<Querier>>();
+        x.rebarbative = j.at("rebarbative").get<std::vector<Rebarbative>>();
+        x.reimagine = j.at("reimagine").get<std::vector<Reimagine>>();
+        x.ressaut = j.at("ressaut").get<Ressaut>();
+        x.retrocervical = j.at("retrocervical").get<std::vector<Retrocervical>>();
+        x.revert = j.at("revert").get<std::vector<Revert>>();
+        x.rewrite = j.at("rewrite").get<std::vector<RewriteElement>>();
+        x.saccoderm = j.at("saccoderm").get<std::vector<Saccoderm>>();
+        x.santir = j.at("santir").get<std::vector<SantirElement>>();
+        x.saprophilous = j.at("saprophilous").get<std::vector<Saprophilous>>();
+        x.saxten = j.at("saxten").get<std::vector<SaxtenElement>>();
+        x.scatty = j.at("scatty").get<std::vector<std::optional<Scatty>>>();
+        x.scoffer = j.at("scoffer").get<std::vector<Scoffer>>();
+        x.scrampum = j.at("scrampum").get<std::vector<Scrampum>>();
+        x.semantic = j.at("semantic").get<double>();
+        x.serpentinic = j.at("serpentinic").get<std::vector<Serpentinic>>();
+        x.shadowable = j.at("shadowable").get<std::vector<Shadowable>>();
+        x.sistering = j.at("sistering").get<std::vector<SisteringElement>>();
+        x.staghunting = j.at("staghunting").get<std::vector<Staghunting>>();
+        x.stagmometer = j.at("stagmometer").get<std::vector<Stagmometer>>();
+        x.stimulability = j.at("stimulability").get<std::vector<Stimulability>>();
+        x.strangleable = j.at("strangleable").get<std::vector<Strangleable>>();
+        x.strenuosity = j.at("strenuosity").get<std::vector<StrenuosityElement>>();
+        x.tabaxir = j.at("tabaxir").get<std::vector<Tabaxir>>();
+        x.talpiform = j.at("talpiform").get<std::vector<Talpiform>>();
+        x.thwack = j.at("thwack").get<std::vector<Thwack>>();
+        x.to = j.at("to").get<std::vector<std::optional<double>>>();
+        x.tortricine = j.at("tortricine").get<std::vector<Tortricine>>();
+        x.truantcy = j.at("truantcy").get<std::vector<TruantcyElement>>();
+        x.turgesce = j.at("turgesce").get<std::vector<std::string>>();
+        x.unbeginning = j.at("unbeginning").get<std::vector<Unbeginning>>();
+        x.underdunged = j.at("underdunged").get<std::vector<double>>();
+        x.undesirability = j.at("undesirability").get<std::vector<Undesirability>>();
+        x.unerasing = j.at("unerasing").get<std::vector<Unerasing>>();
+        x.unguentarium = j.at("unguentarium").get<std::vector<Unguentarium>>();
+        x.unimpeachably = j.at("unimpeachably").get<std::vector<UnimpeachablyElement>>();
+        x.unmortgaged = j.at("unmortgaged").get<std::vector<Unmortgaged>>();
+        x.unobstructed = j.at("unobstructed").get<std::vector<Unobstructed>>();
+        x.unreceptivity = j.at("unreceptivity").get<std::vector<Unreceptivity>>();
+        x.unsatisfactoriness = j.at("unsatisfactoriness").get<std::vector<Unsatisfactoriness>>();
+        x.unsecurity = j.at("unsecurity").get<std::vector<int64_t>>();
+        x.unstressed = j.at("unstressed").get<std::vector<UnstressedElement>>();
+        x.untasked = j.at("untasked").get<std::vector<Untasked>>();
+        x.unvarying = j.at("unvarying").get<std::vector<Unvarying>>();
+        x.vehemently = j.at("vehemently").get<std::vector<Vehemently>>();
+        x.warriorship = j.at("warriorship").get<std::map<std::string, bool>>();
+        x.whitepot = j.at("whitepot").get<std::vector<Whitepot>>();
+        x.wrothy = j.at("wrothy").get<std::vector<WrothyElement>>();
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["protrusive"] = x.protrusive;
+        j["pulpitism"] = x.pulpitism;
+        j["pyodermia"] = x.pyodermia;
+        j["quebrachine"] = x.quebrachine;
+        j["querier"] = x.querier;
+        j["rebarbative"] = x.rebarbative;
+        j["reimagine"] = x.reimagine;
+        j["ressaut"] = x.ressaut;
+        j["retrocervical"] = x.retrocervical;
+        j["revert"] = x.revert;
+        j["rewrite"] = x.rewrite;
+        j["saccoderm"] = x.saccoderm;
+        j["santir"] = x.santir;
+        j["saprophilous"] = x.saprophilous;
+        j["saxten"] = x.saxten;
+        j["scatty"] = x.scatty;
+        j["scoffer"] = x.scoffer;
+        j["scrampum"] = x.scrampum;
+        j["semantic"] = x.semantic;
+        j["serpentinic"] = x.serpentinic;
+        j["shadowable"] = x.shadowable;
+        j["sistering"] = x.sistering;
+        j["staghunting"] = x.staghunting;
+        j["stagmometer"] = x.stagmometer;
+        j["stimulability"] = x.stimulability;
+        j["strangleable"] = x.strangleable;
+        j["strenuosity"] = x.strenuosity;
+        j["tabaxir"] = x.tabaxir;
+        j["talpiform"] = x.talpiform;
+        j["thwack"] = x.thwack;
+        j["to"] = x.to;
+        j["tortricine"] = x.tortricine;
+        j["truantcy"] = x.truantcy;
+        j["turgesce"] = x.turgesce;
+        j["unbeginning"] = x.unbeginning;
+        j["underdunged"] = x.underdunged;
+        j["undesirability"] = x.undesirability;
+        j["unerasing"] = x.unerasing;
+        j["unguentarium"] = x.unguentarium;
+        j["unimpeachably"] = x.unimpeachably;
+        j["unmortgaged"] = x.unmortgaged;
+        j["unobstructed"] = x.unobstructed;
+        j["unreceptivity"] = x.unreceptivity;
+        j["unsatisfactoriness"] = x.unsatisfactoriness;
+        j["unsecurity"] = x.unsecurity;
+        j["unstressed"] = x.unstressed;
+        j["untasked"] = x.untasked;
+        j["unvarying"] = x.unvarying;
+        j["vehemently"] = x.vehemently;
+        j["warriorship"] = x.warriorship;
+        j["whitepot"] = x.whitepot;
+        j["wrothy"] = x.wrothy;
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::PulpitismClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::PulpitismClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>>::from_json(const json & j, std::variant<quicktype::PyodermiaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::PyodermiaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>>::to_json(json & j, const std::variant<quicktype::PyodermiaClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PyodermiaClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass>>::from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass>>::to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::from_json(const json & j, std::variant<bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::to_json(json & j, const std::variant<bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::RewriteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::RewriteClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::RewriteClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SantirClass, double>>::from_json(const json & j, std::variant<quicktype::SantirClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::SantirClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SantirClass, double>>::to_json(json & j, const std::variant<quicktype::SantirClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SantirClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SaxtenClass, std::string>>::from_json(const json & j, std::variant<quicktype::SaxtenClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::SaxtenClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SaxtenClass, std::string>>::to_json(json & j, const std::variant<quicktype::SaxtenClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SaxtenClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::SisteringClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::SisteringClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::from_json(const json & j, std::variant<std::vector<json>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::to_json(json & j, const std::variant<std::vector<json>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::StrenuosityClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::StrenuosityClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::StrenuosityClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(const json & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, const std::variant<bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, double>>::from_json(const json & j, std::variant<quicktype::QuebrachineClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, double>>::to_json(json & j, const std::variant<quicktype::QuebrachineClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>>::from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>>::to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::TruantcyClass>>::from_json(const json & j, std::variant<bool, quicktype::TruantcyClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::TruantcyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::TruantcyClass>>::to_json(json & j, const std::variant<bool, quicktype::TruantcyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::TruantcyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>>::from_json(const json & j, std::variant<bool, quicktype::UnimpeachablyClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnimpeachablyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>>::to_json(json & j, const std::variant<bool, quicktype::UnimpeachablyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::UnimpeachablyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>>::from_json(const json & j, std::variant<quicktype::QuebrachineClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>>::to_json(json & j, const std::variant<quicktype::QuebrachineClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::string>>::from_json(const json & j, std::variant<std::vector<json>, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::string>>::to_json(json & j, const std::variant<std::vector<json>, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>>::from_json(const json & j, std::variant<bool, quicktype::UnstressedClass, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnstressedClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>>::to_json(json & j, const std::variant<bool, quicktype::UnstressedClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::UnstressedClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::from_json(const json & j, std::variant<std::vector<json>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::to_json(json & j, const std::variant<std::vector<json>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::WrothyClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::WrothyClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::WrothyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::WrothyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations4.json/const-style-east-const--0048a2a7a881/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations4.json/const-style-east-const--0048a2a7a881/quicktype.hpp
new file mode 100644
index 0000000..bdfc776
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations4.json/const-style-east-const--0048a2a7a881/quicktype.hpp
@@ -0,0 +1,4365 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, std::shared_ptr<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(json const & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, std::optional<T> const & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(json const & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(json const & j, char const * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(json const & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(json const & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, char const * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(json const & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    using Protrusive = std::variant<std::vector<std::optional<int64_t>>, double>;
+
+    class PulpitismClass {
+        public:
+        PulpitismClass() = default;
+        virtual ~PulpitismClass() = default;
+
+        private:
+        nlohmann::json abnet;
+        nlohmann::json buckhorn;
+        nlohmann::json calciform;
+        nlohmann::json chelophore;
+        nlohmann::json cogitation;
+        nlohmann::json decreeable;
+        nlohmann::json despicable;
+        nlohmann::json isodiazo;
+        nlohmann::json jadedly;
+        nlohmann::json leptochlorite;
+        nlohmann::json nursling;
+        nlohmann::json palamedean;
+        nlohmann::json photoheliograph;
+        nlohmann::json pipewood;
+        nlohmann::json roberd;
+        nlohmann::json statable;
+        nlohmann::json superassume;
+        nlohmann::json syllabe;
+        nlohmann::json toughhead;
+        nlohmann::json underburn;
+
+        public:
+        nlohmann::json const & get_abnet() const { return abnet; }
+        nlohmann::json & get_mutable_abnet() { return abnet; }
+        void set_abnet(nlohmann::json const & value) { this->abnet = value; }
+
+        nlohmann::json const & get_buckhorn() const { return buckhorn; }
+        nlohmann::json & get_mutable_buckhorn() { return buckhorn; }
+        void set_buckhorn(nlohmann::json const & value) { this->buckhorn = value; }
+
+        nlohmann::json const & get_calciform() const { return calciform; }
+        nlohmann::json & get_mutable_calciform() { return calciform; }
+        void set_calciform(nlohmann::json const & value) { this->calciform = value; }
+
+        nlohmann::json const & get_chelophore() const { return chelophore; }
+        nlohmann::json & get_mutable_chelophore() { return chelophore; }
+        void set_chelophore(nlohmann::json const & value) { this->chelophore = value; }
+
+        nlohmann::json const & get_cogitation() const { return cogitation; }
+        nlohmann::json & get_mutable_cogitation() { return cogitation; }
+        void set_cogitation(nlohmann::json const & value) { this->cogitation = value; }
+
+        nlohmann::json const & get_decreeable() const { return decreeable; }
+        nlohmann::json & get_mutable_decreeable() { return decreeable; }
+        void set_decreeable(nlohmann::json const & value) { this->decreeable = value; }
+
+        nlohmann::json const & get_despicable() const { return despicable; }
+        nlohmann::json & get_mutable_despicable() { return despicable; }
+        void set_despicable(nlohmann::json const & value) { this->despicable = value; }
+
+        nlohmann::json const & get_isodiazo() const { return isodiazo; }
+        nlohmann::json & get_mutable_isodiazo() { return isodiazo; }
+        void set_isodiazo(nlohmann::json const & value) { this->isodiazo = value; }
+
+        nlohmann::json const & get_jadedly() const { return jadedly; }
+        nlohmann::json & get_mutable_jadedly() { return jadedly; }
+        void set_jadedly(nlohmann::json const & value) { this->jadedly = value; }
+
+        nlohmann::json const & get_leptochlorite() const { return leptochlorite; }
+        nlohmann::json & get_mutable_leptochlorite() { return leptochlorite; }
+        void set_leptochlorite(nlohmann::json const & value) { this->leptochlorite = value; }
+
+        nlohmann::json const & get_nursling() const { return nursling; }
+        nlohmann::json & get_mutable_nursling() { return nursling; }
+        void set_nursling(nlohmann::json const & value) { this->nursling = value; }
+
+        nlohmann::json const & get_palamedean() const { return palamedean; }
+        nlohmann::json & get_mutable_palamedean() { return palamedean; }
+        void set_palamedean(nlohmann::json const & value) { this->palamedean = value; }
+
+        nlohmann::json const & get_photoheliograph() const { return photoheliograph; }
+        nlohmann::json & get_mutable_photoheliograph() { return photoheliograph; }
+        void set_photoheliograph(nlohmann::json const & value) { this->photoheliograph = value; }
+
+        nlohmann::json const & get_pipewood() const { return pipewood; }
+        nlohmann::json & get_mutable_pipewood() { return pipewood; }
+        void set_pipewood(nlohmann::json const & value) { this->pipewood = value; }
+
+        nlohmann::json const & get_roberd() const { return roberd; }
+        nlohmann::json & get_mutable_roberd() { return roberd; }
+        void set_roberd(nlohmann::json const & value) { this->roberd = value; }
+
+        nlohmann::json const & get_statable() const { return statable; }
+        nlohmann::json & get_mutable_statable() { return statable; }
+        void set_statable(nlohmann::json const & value) { this->statable = value; }
+
+        nlohmann::json const & get_superassume() const { return superassume; }
+        nlohmann::json & get_mutable_superassume() { return superassume; }
+        void set_superassume(nlohmann::json const & value) { this->superassume = value; }
+
+        nlohmann::json const & get_syllabe() const { return syllabe; }
+        nlohmann::json & get_mutable_syllabe() { return syllabe; }
+        void set_syllabe(nlohmann::json const & value) { this->syllabe = value; }
+
+        nlohmann::json const & get_toughhead() const { return toughhead; }
+        nlohmann::json & get_mutable_toughhead() { return toughhead; }
+        void set_toughhead(nlohmann::json const & value) { this->toughhead = value; }
+
+        nlohmann::json const & get_underburn() const { return underburn; }
+        nlohmann::json & get_mutable_underburn() { return underburn; }
+        void set_underburn(nlohmann::json const & value) { this->underburn = value; }
+    };
+
+    using PulpitismElement = std::variant<std::vector<int64_t>, PulpitismClass, double>;
+
+    class PyodermiaClass {
+        public:
+        PyodermiaClass() = default;
+        virtual ~PyodermiaClass() = default;
+
+        private:
+        nlohmann::json aphoristically;
+        nlohmann::json apophyllous;
+        nlohmann::json cognize;
+        nlohmann::json dermonosology;
+        nlohmann::json gyppo;
+        nlohmann::json ither;
+        nlohmann::json juglandaceous;
+        nlohmann::json litho;
+        nlohmann::json macropterous;
+        nlohmann::json photographer;
+        nlohmann::json romancing;
+        nlohmann::json rumness;
+        nlohmann::json somniloquist;
+        nlohmann::json stressfully;
+        nlohmann::json tactically;
+        nlohmann::json tracheophony;
+        nlohmann::json unappositely;
+        nlohmann::json unclothedly;
+        nlohmann::json unimplied;
+        nlohmann::json unsyncopated;
+
+        public:
+        nlohmann::json const & get_aphoristically() const { return aphoristically; }
+        nlohmann::json & get_mutable_aphoristically() { return aphoristically; }
+        void set_aphoristically(nlohmann::json const & value) { this->aphoristically = value; }
+
+        nlohmann::json const & get_apophyllous() const { return apophyllous; }
+        nlohmann::json & get_mutable_apophyllous() { return apophyllous; }
+        void set_apophyllous(nlohmann::json const & value) { this->apophyllous = value; }
+
+        nlohmann::json const & get_cognize() const { return cognize; }
+        nlohmann::json & get_mutable_cognize() { return cognize; }
+        void set_cognize(nlohmann::json const & value) { this->cognize = value; }
+
+        nlohmann::json const & get_dermonosology() const { return dermonosology; }
+        nlohmann::json & get_mutable_dermonosology() { return dermonosology; }
+        void set_dermonosology(nlohmann::json const & value) { this->dermonosology = value; }
+
+        nlohmann::json const & get_gyppo() const { return gyppo; }
+        nlohmann::json & get_mutable_gyppo() { return gyppo; }
+        void set_gyppo(nlohmann::json const & value) { this->gyppo = value; }
+
+        nlohmann::json const & get_ither() const { return ither; }
+        nlohmann::json & get_mutable_ither() { return ither; }
+        void set_ither(nlohmann::json const & value) { this->ither = value; }
+
+        nlohmann::json const & get_juglandaceous() const { return juglandaceous; }
+        nlohmann::json & get_mutable_juglandaceous() { return juglandaceous; }
+        void set_juglandaceous(nlohmann::json const & value) { this->juglandaceous = value; }
+
+        nlohmann::json const & get_litho() const { return litho; }
+        nlohmann::json & get_mutable_litho() { return litho; }
+        void set_litho(nlohmann::json const & value) { this->litho = value; }
+
+        nlohmann::json const & get_macropterous() const { return macropterous; }
+        nlohmann::json & get_mutable_macropterous() { return macropterous; }
+        void set_macropterous(nlohmann::json const & value) { this->macropterous = value; }
+
+        nlohmann::json const & get_photographer() const { return photographer; }
+        nlohmann::json & get_mutable_photographer() { return photographer; }
+        void set_photographer(nlohmann::json const & value) { this->photographer = value; }
+
+        nlohmann::json const & get_romancing() const { return romancing; }
+        nlohmann::json & get_mutable_romancing() { return romancing; }
+        void set_romancing(nlohmann::json const & value) { this->romancing = value; }
+
+        nlohmann::json const & get_rumness() const { return rumness; }
+        nlohmann::json & get_mutable_rumness() { return rumness; }
+        void set_rumness(nlohmann::json const & value) { this->rumness = value; }
+
+        nlohmann::json const & get_somniloquist() const { return somniloquist; }
+        nlohmann::json & get_mutable_somniloquist() { return somniloquist; }
+        void set_somniloquist(nlohmann::json const & value) { this->somniloquist = value; }
+
+        nlohmann::json const & get_stressfully() const { return stressfully; }
+        nlohmann::json & get_mutable_stressfully() { return stressfully; }
+        void set_stressfully(nlohmann::json const & value) { this->stressfully = value; }
+
+        nlohmann::json const & get_tactically() const { return tactically; }
+        nlohmann::json & get_mutable_tactically() { return tactically; }
+        void set_tactically(nlohmann::json const & value) { this->tactically = value; }
+
+        nlohmann::json const & get_tracheophony() const { return tracheophony; }
+        nlohmann::json & get_mutable_tracheophony() { return tracheophony; }
+        void set_tracheophony(nlohmann::json const & value) { this->tracheophony = value; }
+
+        nlohmann::json const & get_unappositely() const { return unappositely; }
+        nlohmann::json & get_mutable_unappositely() { return unappositely; }
+        void set_unappositely(nlohmann::json const & value) { this->unappositely = value; }
+
+        nlohmann::json const & get_unclothedly() const { return unclothedly; }
+        nlohmann::json & get_mutable_unclothedly() { return unclothedly; }
+        void set_unclothedly(nlohmann::json const & value) { this->unclothedly = value; }
+
+        nlohmann::json const & get_unimplied() const { return unimplied; }
+        nlohmann::json & get_mutable_unimplied() { return unimplied; }
+        void set_unimplied(nlohmann::json const & value) { this->unimplied = value; }
+
+        nlohmann::json const & get_unsyncopated() const { return unsyncopated; }
+        nlohmann::json & get_mutable_unsyncopated() { return unsyncopated; }
+        void set_unsyncopated(nlohmann::json const & value) { this->unsyncopated = value; }
+    };
+
+    using PyodermiaElement = std::variant<PyodermiaClass, int64_t>;
+
+    class QuebrachineClass {
+        public:
+        QuebrachineClass() = default;
+        virtual ~QuebrachineClass() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        double const & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(double const & value) { this->catharticalness = value; }
+
+        int64_t const & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(int64_t const & value) { this->chirotherium = value; }
+
+        std::string const & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::string const & value) { this->disdiapason = value; }
+
+        bool const & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(bool const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+    };
+
+    using QuebrachineElement = std::optional<std::variant<bool, QuebrachineClass>>;
+
+    using Querier = std::variant<bool, std::map<std::string, int64_t>>;
+
+    using Rebarbative = std::variant<std::vector<int64_t>, bool, double>;
+
+    class Reimagine {
+        public:
+        Reimagine() = default;
+        virtual ~Reimagine() = default;
+
+        private:
+        nlohmann::json adducible;
+        nlohmann::json anabolin;
+        nlohmann::json brainy;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json chrysamine;
+        std::optional<std::string> disdiapason;
+        nlohmann::json fluxweed;
+        nlohmann::json glaucine;
+        nlohmann::json grobianism;
+        nlohmann::json hermo;
+        nlohmann::json hieroglyphist;
+        std::optional<bool> homocerc;
+        nlohmann::json icteroid;
+        nlohmann::json immortal;
+        nlohmann::json impetulant;
+        nlohmann::json irrigate;
+        nlohmann::json myxedema;
+        nlohmann::json nonbookish;
+        nlohmann::json onyx;
+        nlohmann::json repasser;
+        nlohmann::json septomarginal;
+        nlohmann::json subdie;
+        nlohmann::json tibiometatarsal;
+        nlohmann::json waltzlike;
+
+        public:
+        nlohmann::json const & get_adducible() const { return adducible; }
+        nlohmann::json & get_mutable_adducible() { return adducible; }
+        void set_adducible(nlohmann::json const & value) { this->adducible = value; }
+
+        nlohmann::json const & get_anabolin() const { return anabolin; }
+        nlohmann::json & get_mutable_anabolin() { return anabolin; }
+        void set_anabolin(nlohmann::json const & value) { this->anabolin = value; }
+
+        nlohmann::json const & get_brainy() const { return brainy; }
+        nlohmann::json & get_mutable_brainy() { return brainy; }
+        void set_brainy(nlohmann::json const & value) { this->brainy = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        nlohmann::json const & get_chrysamine() const { return chrysamine; }
+        nlohmann::json & get_mutable_chrysamine() { return chrysamine; }
+        void set_chrysamine(nlohmann::json const & value) { this->chrysamine = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_fluxweed() const { return fluxweed; }
+        nlohmann::json & get_mutable_fluxweed() { return fluxweed; }
+        void set_fluxweed(nlohmann::json const & value) { this->fluxweed = value; }
+
+        nlohmann::json const & get_glaucine() const { return glaucine; }
+        nlohmann::json & get_mutable_glaucine() { return glaucine; }
+        void set_glaucine(nlohmann::json const & value) { this->glaucine = value; }
+
+        nlohmann::json const & get_grobianism() const { return grobianism; }
+        nlohmann::json & get_mutable_grobianism() { return grobianism; }
+        void set_grobianism(nlohmann::json const & value) { this->grobianism = value; }
+
+        nlohmann::json const & get_hermo() const { return hermo; }
+        nlohmann::json & get_mutable_hermo() { return hermo; }
+        void set_hermo(nlohmann::json const & value) { this->hermo = value; }
+
+        nlohmann::json const & get_hieroglyphist() const { return hieroglyphist; }
+        nlohmann::json & get_mutable_hieroglyphist() { return hieroglyphist; }
+        void set_hieroglyphist(nlohmann::json const & value) { this->hieroglyphist = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_icteroid() const { return icteroid; }
+        nlohmann::json & get_mutable_icteroid() { return icteroid; }
+        void set_icteroid(nlohmann::json const & value) { this->icteroid = value; }
+
+        nlohmann::json const & get_immortal() const { return immortal; }
+        nlohmann::json & get_mutable_immortal() { return immortal; }
+        void set_immortal(nlohmann::json const & value) { this->immortal = value; }
+
+        nlohmann::json const & get_impetulant() const { return impetulant; }
+        nlohmann::json & get_mutable_impetulant() { return impetulant; }
+        void set_impetulant(nlohmann::json const & value) { this->impetulant = value; }
+
+        nlohmann::json const & get_irrigate() const { return irrigate; }
+        nlohmann::json & get_mutable_irrigate() { return irrigate; }
+        void set_irrigate(nlohmann::json const & value) { this->irrigate = value; }
+
+        nlohmann::json const & get_myxedema() const { return myxedema; }
+        nlohmann::json & get_mutable_myxedema() { return myxedema; }
+        void set_myxedema(nlohmann::json const & value) { this->myxedema = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_onyx() const { return onyx; }
+        nlohmann::json & get_mutable_onyx() { return onyx; }
+        void set_onyx(nlohmann::json const & value) { this->onyx = value; }
+
+        nlohmann::json const & get_repasser() const { return repasser; }
+        nlohmann::json & get_mutable_repasser() { return repasser; }
+        void set_repasser(nlohmann::json const & value) { this->repasser = value; }
+
+        nlohmann::json const & get_septomarginal() const { return septomarginal; }
+        nlohmann::json & get_mutable_septomarginal() { return septomarginal; }
+        void set_septomarginal(nlohmann::json const & value) { this->septomarginal = value; }
+
+        nlohmann::json const & get_subdie() const { return subdie; }
+        nlohmann::json & get_mutable_subdie() { return subdie; }
+        void set_subdie(nlohmann::json const & value) { this->subdie = value; }
+
+        nlohmann::json const & get_tibiometatarsal() const { return tibiometatarsal; }
+        nlohmann::json & get_mutable_tibiometatarsal() { return tibiometatarsal; }
+        void set_tibiometatarsal(nlohmann::json const & value) { this->tibiometatarsal = value; }
+
+        nlohmann::json const & get_waltzlike() const { return waltzlike; }
+        nlohmann::json & get_mutable_waltzlike() { return waltzlike; }
+        void set_waltzlike(nlohmann::json const & value) { this->waltzlike = value; }
+    };
+
+    class Ressaut {
+        public:
+        Ressaut() = default;
+        virtual ~Ressaut() = default;
+
+        private:
+        std::string apperceptive;
+        std::string cuttoo;
+        std::string douser;
+        std::string drinkproof;
+        std::string forementioned;
+        std::string freesia;
+        std::string genevieve;
+        std::string hyperdiabolical;
+        std::string hypocone;
+        std::string irreverentially;
+        std::string jumart;
+        std::string mimosaceae;
+        std::string mollicrush;
+        std::string nedder;
+        std::string retinasphalt;
+        std::string sough;
+        std::string steading;
+        std::string theopaschitism;
+        std::string undurableness;
+        std::string unmingleable;
+
+        public:
+        std::string const & get_apperceptive() const { return apperceptive; }
+        std::string & get_mutable_apperceptive() { return apperceptive; }
+        void set_apperceptive(std::string const & value) { this->apperceptive = value; }
+
+        std::string const & get_cuttoo() const { return cuttoo; }
+        std::string & get_mutable_cuttoo() { return cuttoo; }
+        void set_cuttoo(std::string const & value) { this->cuttoo = value; }
+
+        std::string const & get_douser() const { return douser; }
+        std::string & get_mutable_douser() { return douser; }
+        void set_douser(std::string const & value) { this->douser = value; }
+
+        std::string const & get_drinkproof() const { return drinkproof; }
+        std::string & get_mutable_drinkproof() { return drinkproof; }
+        void set_drinkproof(std::string const & value) { this->drinkproof = value; }
+
+        std::string const & get_forementioned() const { return forementioned; }
+        std::string & get_mutable_forementioned() { return forementioned; }
+        void set_forementioned(std::string const & value) { this->forementioned = value; }
+
+        std::string const & get_freesia() const { return freesia; }
+        std::string & get_mutable_freesia() { return freesia; }
+        void set_freesia(std::string const & value) { this->freesia = value; }
+
+        std::string const & get_genevieve() const { return genevieve; }
+        std::string & get_mutable_genevieve() { return genevieve; }
+        void set_genevieve(std::string const & value) { this->genevieve = value; }
+
+        std::string const & get_hyperdiabolical() const { return hyperdiabolical; }
+        std::string & get_mutable_hyperdiabolical() { return hyperdiabolical; }
+        void set_hyperdiabolical(std::string const & value) { this->hyperdiabolical = value; }
+
+        std::string const & get_hypocone() const { return hypocone; }
+        std::string & get_mutable_hypocone() { return hypocone; }
+        void set_hypocone(std::string const & value) { this->hypocone = value; }
+
+        std::string const & get_irreverentially() const { return irreverentially; }
+        std::string & get_mutable_irreverentially() { return irreverentially; }
+        void set_irreverentially(std::string const & value) { this->irreverentially = value; }
+
+        std::string const & get_jumart() const { return jumart; }
+        std::string & get_mutable_jumart() { return jumart; }
+        void set_jumart(std::string const & value) { this->jumart = value; }
+
+        std::string const & get_mimosaceae() const { return mimosaceae; }
+        std::string & get_mutable_mimosaceae() { return mimosaceae; }
+        void set_mimosaceae(std::string const & value) { this->mimosaceae = value; }
+
+        std::string const & get_mollicrush() const { return mollicrush; }
+        std::string & get_mutable_mollicrush() { return mollicrush; }
+        void set_mollicrush(std::string const & value) { this->mollicrush = value; }
+
+        std::string const & get_nedder() const { return nedder; }
+        std::string & get_mutable_nedder() { return nedder; }
+        void set_nedder(std::string const & value) { this->nedder = value; }
+
+        std::string const & get_retinasphalt() const { return retinasphalt; }
+        std::string & get_mutable_retinasphalt() { return retinasphalt; }
+        void set_retinasphalt(std::string const & value) { this->retinasphalt = value; }
+
+        std::string const & get_sough() const { return sough; }
+        std::string & get_mutable_sough() { return sough; }
+        void set_sough(std::string const & value) { this->sough = value; }
+
+        std::string const & get_steading() const { return steading; }
+        std::string & get_mutable_steading() { return steading; }
+        void set_steading(std::string const & value) { this->steading = value; }
+
+        std::string const & get_theopaschitism() const { return theopaschitism; }
+        std::string & get_mutable_theopaschitism() { return theopaschitism; }
+        void set_theopaschitism(std::string const & value) { this->theopaschitism = value; }
+
+        std::string const & get_undurableness() const { return undurableness; }
+        std::string & get_mutable_undurableness() { return undurableness; }
+        void set_undurableness(std::string const & value) { this->undurableness = value; }
+
+        std::string const & get_unmingleable() const { return unmingleable; }
+        std::string & get_mutable_unmingleable() { return unmingleable; }
+        void set_unmingleable(std::string const & value) { this->unmingleable = value; }
+    };
+
+    using Retrocervical = std::variant<std::vector<std::optional<int64_t>>, int64_t>;
+
+    using Revert = std::variant<bool, std::string>;
+
+    class RewriteClass {
+        public:
+        RewriteClass() = default;
+        virtual ~RewriteClass() = default;
+
+        private:
+        nlohmann::json accountancy;
+        nlohmann::json cacotrophic;
+        nlohmann::json contest;
+        nlohmann::json couthily;
+        nlohmann::json falculate;
+        nlohmann::json foreseize;
+        nlohmann::json hyades;
+        nlohmann::json lemnad;
+        nlohmann::json monotheistically;
+        nlohmann::json nonflying;
+        nlohmann::json ptenoglossa;
+        nlohmann::json repatch;
+        nlohmann::json rodman;
+        nlohmann::json strung;
+        nlohmann::json titmal;
+        nlohmann::json twalpennyworth;
+        nlohmann::json unblamable;
+        nlohmann::json vertical;
+        nlohmann::json whiggification;
+        nlohmann::json yardman;
+
+        public:
+        nlohmann::json const & get_accountancy() const { return accountancy; }
+        nlohmann::json & get_mutable_accountancy() { return accountancy; }
+        void set_accountancy(nlohmann::json const & value) { this->accountancy = value; }
+
+        nlohmann::json const & get_cacotrophic() const { return cacotrophic; }
+        nlohmann::json & get_mutable_cacotrophic() { return cacotrophic; }
+        void set_cacotrophic(nlohmann::json const & value) { this->cacotrophic = value; }
+
+        nlohmann::json const & get_contest() const { return contest; }
+        nlohmann::json & get_mutable_contest() { return contest; }
+        void set_contest(nlohmann::json const & value) { this->contest = value; }
+
+        nlohmann::json const & get_couthily() const { return couthily; }
+        nlohmann::json & get_mutable_couthily() { return couthily; }
+        void set_couthily(nlohmann::json const & value) { this->couthily = value; }
+
+        nlohmann::json const & get_falculate() const { return falculate; }
+        nlohmann::json & get_mutable_falculate() { return falculate; }
+        void set_falculate(nlohmann::json const & value) { this->falculate = value; }
+
+        nlohmann::json const & get_foreseize() const { return foreseize; }
+        nlohmann::json & get_mutable_foreseize() { return foreseize; }
+        void set_foreseize(nlohmann::json const & value) { this->foreseize = value; }
+
+        nlohmann::json const & get_hyades() const { return hyades; }
+        nlohmann::json & get_mutable_hyades() { return hyades; }
+        void set_hyades(nlohmann::json const & value) { this->hyades = value; }
+
+        nlohmann::json const & get_lemnad() const { return lemnad; }
+        nlohmann::json & get_mutable_lemnad() { return lemnad; }
+        void set_lemnad(nlohmann::json const & value) { this->lemnad = value; }
+
+        nlohmann::json const & get_monotheistically() const { return monotheistically; }
+        nlohmann::json & get_mutable_monotheistically() { return monotheistically; }
+        void set_monotheistically(nlohmann::json const & value) { this->monotheistically = value; }
+
+        nlohmann::json const & get_nonflying() const { return nonflying; }
+        nlohmann::json & get_mutable_nonflying() { return nonflying; }
+        void set_nonflying(nlohmann::json const & value) { this->nonflying = value; }
+
+        nlohmann::json const & get_ptenoglossa() const { return ptenoglossa; }
+        nlohmann::json & get_mutable_ptenoglossa() { return ptenoglossa; }
+        void set_ptenoglossa(nlohmann::json const & value) { this->ptenoglossa = value; }
+
+        nlohmann::json const & get_repatch() const { return repatch; }
+        nlohmann::json & get_mutable_repatch() { return repatch; }
+        void set_repatch(nlohmann::json const & value) { this->repatch = value; }
+
+        nlohmann::json const & get_rodman() const { return rodman; }
+        nlohmann::json & get_mutable_rodman() { return rodman; }
+        void set_rodman(nlohmann::json const & value) { this->rodman = value; }
+
+        nlohmann::json const & get_strung() const { return strung; }
+        nlohmann::json & get_mutable_strung() { return strung; }
+        void set_strung(nlohmann::json const & value) { this->strung = value; }
+
+        nlohmann::json const & get_titmal() const { return titmal; }
+        nlohmann::json & get_mutable_titmal() { return titmal; }
+        void set_titmal(nlohmann::json const & value) { this->titmal = value; }
+
+        nlohmann::json const & get_twalpennyworth() const { return twalpennyworth; }
+        nlohmann::json & get_mutable_twalpennyworth() { return twalpennyworth; }
+        void set_twalpennyworth(nlohmann::json const & value) { this->twalpennyworth = value; }
+
+        nlohmann::json const & get_unblamable() const { return unblamable; }
+        nlohmann::json & get_mutable_unblamable() { return unblamable; }
+        void set_unblamable(nlohmann::json const & value) { this->unblamable = value; }
+
+        nlohmann::json const & get_vertical() const { return vertical; }
+        nlohmann::json & get_mutable_vertical() { return vertical; }
+        void set_vertical(nlohmann::json const & value) { this->vertical = value; }
+
+        nlohmann::json const & get_whiggification() const { return whiggification; }
+        nlohmann::json & get_mutable_whiggification() { return whiggification; }
+        void set_whiggification(nlohmann::json const & value) { this->whiggification = value; }
+
+        nlohmann::json const & get_yardman() const { return yardman; }
+        nlohmann::json & get_mutable_yardman() { return yardman; }
+        void set_yardman(nlohmann::json const & value) { this->yardman = value; }
+    };
+
+    using RewriteElement = std::variant<std::vector<nlohmann::json>, RewriteClass, double>;
+
+    using Saccoderm = std::optional<std::variant<std::vector<int64_t>, std::string>>;
+
+    class SantirClass {
+        public:
+        SantirClass() = default;
+        virtual ~SantirClass() = default;
+
+        private:
+        nlohmann::json admiredly;
+        nlohmann::json demicaponier;
+        nlohmann::json epitympanic;
+        nlohmann::json investitor;
+        nlohmann::json lupiform;
+        nlohmann::json monoflagellate;
+        nlohmann::json paleoethnic;
+        nlohmann::json prediscountable;
+        nlohmann::json rhetoricals;
+        nlohmann::json roomth;
+        nlohmann::json saccharose;
+        nlohmann::json septonasal;
+        nlohmann::json serpenticide;
+        nlohmann::json setarious;
+        nlohmann::json spaework;
+        nlohmann::json stylite;
+        nlohmann::json suessiones;
+        nlohmann::json timelily;
+        nlohmann::json unprofaned;
+        nlohmann::json vorticular;
+
+        public:
+        nlohmann::json const & get_admiredly() const { return admiredly; }
+        nlohmann::json & get_mutable_admiredly() { return admiredly; }
+        void set_admiredly(nlohmann::json const & value) { this->admiredly = value; }
+
+        nlohmann::json const & get_demicaponier() const { return demicaponier; }
+        nlohmann::json & get_mutable_demicaponier() { return demicaponier; }
+        void set_demicaponier(nlohmann::json const & value) { this->demicaponier = value; }
+
+        nlohmann::json const & get_epitympanic() const { return epitympanic; }
+        nlohmann::json & get_mutable_epitympanic() { return epitympanic; }
+        void set_epitympanic(nlohmann::json const & value) { this->epitympanic = value; }
+
+        nlohmann::json const & get_investitor() const { return investitor; }
+        nlohmann::json & get_mutable_investitor() { return investitor; }
+        void set_investitor(nlohmann::json const & value) { this->investitor = value; }
+
+        nlohmann::json const & get_lupiform() const { return lupiform; }
+        nlohmann::json & get_mutable_lupiform() { return lupiform; }
+        void set_lupiform(nlohmann::json const & value) { this->lupiform = value; }
+
+        nlohmann::json const & get_monoflagellate() const { return monoflagellate; }
+        nlohmann::json & get_mutable_monoflagellate() { return monoflagellate; }
+        void set_monoflagellate(nlohmann::json const & value) { this->monoflagellate = value; }
+
+        nlohmann::json const & get_paleoethnic() const { return paleoethnic; }
+        nlohmann::json & get_mutable_paleoethnic() { return paleoethnic; }
+        void set_paleoethnic(nlohmann::json const & value) { this->paleoethnic = value; }
+
+        nlohmann::json const & get_prediscountable() const { return prediscountable; }
+        nlohmann::json & get_mutable_prediscountable() { return prediscountable; }
+        void set_prediscountable(nlohmann::json const & value) { this->prediscountable = value; }
+
+        nlohmann::json const & get_rhetoricals() const { return rhetoricals; }
+        nlohmann::json & get_mutable_rhetoricals() { return rhetoricals; }
+        void set_rhetoricals(nlohmann::json const & value) { this->rhetoricals = value; }
+
+        nlohmann::json const & get_roomth() const { return roomth; }
+        nlohmann::json & get_mutable_roomth() { return roomth; }
+        void set_roomth(nlohmann::json const & value) { this->roomth = value; }
+
+        nlohmann::json const & get_saccharose() const { return saccharose; }
+        nlohmann::json & get_mutable_saccharose() { return saccharose; }
+        void set_saccharose(nlohmann::json const & value) { this->saccharose = value; }
+
+        nlohmann::json const & get_septonasal() const { return septonasal; }
+        nlohmann::json & get_mutable_septonasal() { return septonasal; }
+        void set_septonasal(nlohmann::json const & value) { this->septonasal = value; }
+
+        nlohmann::json const & get_serpenticide() const { return serpenticide; }
+        nlohmann::json & get_mutable_serpenticide() { return serpenticide; }
+        void set_serpenticide(nlohmann::json const & value) { this->serpenticide = value; }
+
+        nlohmann::json const & get_setarious() const { return setarious; }
+        nlohmann::json & get_mutable_setarious() { return setarious; }
+        void set_setarious(nlohmann::json const & value) { this->setarious = value; }
+
+        nlohmann::json const & get_spaework() const { return spaework; }
+        nlohmann::json & get_mutable_spaework() { return spaework; }
+        void set_spaework(nlohmann::json const & value) { this->spaework = value; }
+
+        nlohmann::json const & get_stylite() const { return stylite; }
+        nlohmann::json & get_mutable_stylite() { return stylite; }
+        void set_stylite(nlohmann::json const & value) { this->stylite = value; }
+
+        nlohmann::json const & get_suessiones() const { return suessiones; }
+        nlohmann::json & get_mutable_suessiones() { return suessiones; }
+        void set_suessiones(nlohmann::json const & value) { this->suessiones = value; }
+
+        nlohmann::json const & get_timelily() const { return timelily; }
+        nlohmann::json & get_mutable_timelily() { return timelily; }
+        void set_timelily(nlohmann::json const & value) { this->timelily = value; }
+
+        nlohmann::json const & get_unprofaned() const { return unprofaned; }
+        nlohmann::json & get_mutable_unprofaned() { return unprofaned; }
+        void set_unprofaned(nlohmann::json const & value) { this->unprofaned = value; }
+
+        nlohmann::json const & get_vorticular() const { return vorticular; }
+        nlohmann::json & get_mutable_vorticular() { return vorticular; }
+        void set_vorticular(nlohmann::json const & value) { this->vorticular = value; }
+    };
+
+    using SantirElement = std::variant<SantirClass, double>;
+
+    using Saprophilous = std::optional<std::variant<std::map<std::string, int64_t>, std::string>>;
+
+    class SaxtenClass {
+        public:
+        SaxtenClass() = default;
+        virtual ~SaxtenClass() = default;
+
+        private:
+        nlohmann::json algarrobilla;
+        nlohmann::json bowgrace;
+        std::optional<double> catharticalness;
+        nlohmann::json centaurid;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json flix;
+        nlohmann::json germanely;
+        std::optional<bool> homocerc;
+        nlohmann::json inhume;
+        nlohmann::json lepidote;
+        nlohmann::json megalochirous;
+        nlohmann::json ninepenny;
+        nlohmann::json nonbookish;
+        nlohmann::json nondeist;
+        nlohmann::json nymphaeaceous;
+        nlohmann::json parietofrontal;
+        nlohmann::json sancyite;
+        nlohmann::json subjectivist;
+        nlohmann::json tibiad;
+        nlohmann::json transonic;
+        nlohmann::json tripetalous;
+        nlohmann::json trunchman;
+        nlohmann::json urger;
+        nlohmann::json withdrawnness;
+
+        public:
+        nlohmann::json const & get_algarrobilla() const { return algarrobilla; }
+        nlohmann::json & get_mutable_algarrobilla() { return algarrobilla; }
+        void set_algarrobilla(nlohmann::json const & value) { this->algarrobilla = value; }
+
+        nlohmann::json const & get_bowgrace() const { return bowgrace; }
+        nlohmann::json & get_mutable_bowgrace() { return bowgrace; }
+        void set_bowgrace(nlohmann::json const & value) { this->bowgrace = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        nlohmann::json const & get_centaurid() const { return centaurid; }
+        nlohmann::json & get_mutable_centaurid() { return centaurid; }
+        void set_centaurid(nlohmann::json const & value) { this->centaurid = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_flix() const { return flix; }
+        nlohmann::json & get_mutable_flix() { return flix; }
+        void set_flix(nlohmann::json const & value) { this->flix = value; }
+
+        nlohmann::json const & get_germanely() const { return germanely; }
+        nlohmann::json & get_mutable_germanely() { return germanely; }
+        void set_germanely(nlohmann::json const & value) { this->germanely = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_inhume() const { return inhume; }
+        nlohmann::json & get_mutable_inhume() { return inhume; }
+        void set_inhume(nlohmann::json const & value) { this->inhume = value; }
+
+        nlohmann::json const & get_lepidote() const { return lepidote; }
+        nlohmann::json & get_mutable_lepidote() { return lepidote; }
+        void set_lepidote(nlohmann::json const & value) { this->lepidote = value; }
+
+        nlohmann::json const & get_megalochirous() const { return megalochirous; }
+        nlohmann::json & get_mutable_megalochirous() { return megalochirous; }
+        void set_megalochirous(nlohmann::json const & value) { this->megalochirous = value; }
+
+        nlohmann::json const & get_ninepenny() const { return ninepenny; }
+        nlohmann::json & get_mutable_ninepenny() { return ninepenny; }
+        void set_ninepenny(nlohmann::json const & value) { this->ninepenny = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_nondeist() const { return nondeist; }
+        nlohmann::json & get_mutable_nondeist() { return nondeist; }
+        void set_nondeist(nlohmann::json const & value) { this->nondeist = value; }
+
+        nlohmann::json const & get_nymphaeaceous() const { return nymphaeaceous; }
+        nlohmann::json & get_mutable_nymphaeaceous() { return nymphaeaceous; }
+        void set_nymphaeaceous(nlohmann::json const & value) { this->nymphaeaceous = value; }
+
+        nlohmann::json const & get_parietofrontal() const { return parietofrontal; }
+        nlohmann::json & get_mutable_parietofrontal() { return parietofrontal; }
+        void set_parietofrontal(nlohmann::json const & value) { this->parietofrontal = value; }
+
+        nlohmann::json const & get_sancyite() const { return sancyite; }
+        nlohmann::json & get_mutable_sancyite() { return sancyite; }
+        void set_sancyite(nlohmann::json const & value) { this->sancyite = value; }
+
+        nlohmann::json const & get_subjectivist() const { return subjectivist; }
+        nlohmann::json & get_mutable_subjectivist() { return subjectivist; }
+        void set_subjectivist(nlohmann::json const & value) { this->subjectivist = value; }
+
+        nlohmann::json const & get_tibiad() const { return tibiad; }
+        nlohmann::json & get_mutable_tibiad() { return tibiad; }
+        void set_tibiad(nlohmann::json const & value) { this->tibiad = value; }
+
+        nlohmann::json const & get_transonic() const { return transonic; }
+        nlohmann::json & get_mutable_transonic() { return transonic; }
+        void set_transonic(nlohmann::json const & value) { this->transonic = value; }
+
+        nlohmann::json const & get_tripetalous() const { return tripetalous; }
+        nlohmann::json & get_mutable_tripetalous() { return tripetalous; }
+        void set_tripetalous(nlohmann::json const & value) { this->tripetalous = value; }
+
+        nlohmann::json const & get_trunchman() const { return trunchman; }
+        nlohmann::json & get_mutable_trunchman() { return trunchman; }
+        void set_trunchman(nlohmann::json const & value) { this->trunchman = value; }
+
+        nlohmann::json const & get_urger() const { return urger; }
+        nlohmann::json & get_mutable_urger() { return urger; }
+        void set_urger(nlohmann::json const & value) { this->urger = value; }
+
+        nlohmann::json const & get_withdrawnness() const { return withdrawnness; }
+        nlohmann::json & get_mutable_withdrawnness() { return withdrawnness; }
+        void set_withdrawnness(nlohmann::json const & value) { this->withdrawnness = value; }
+    };
+
+    using SaxtenElement = std::variant<SaxtenClass, std::string>;
+
+    class Scatty {
+        public:
+        Scatty() = default;
+        virtual ~Scatty() = default;
+
+        private:
+        nlohmann::json aeriferous;
+        nlohmann::json antical;
+        nlohmann::json antighostism;
+        nlohmann::json arcanum;
+        nlohmann::json autotrophy;
+        nlohmann::json baronial;
+        nlohmann::json caffeine;
+        nlohmann::json gorgoniacean;
+        nlohmann::json heroical;
+        nlohmann::json hydropical;
+        nlohmann::json mechanology;
+        nlohmann::json musicopoetic;
+        nlohmann::json officiality;
+        nlohmann::json oftentimes;
+        nlohmann::json ophthalmotonometer;
+        nlohmann::json reflectively;
+        nlohmann::json springer;
+        nlohmann::json tabasco;
+        nlohmann::json teleianthous;
+        nlohmann::json uncombated;
+
+        public:
+        nlohmann::json const & get_aeriferous() const { return aeriferous; }
+        nlohmann::json & get_mutable_aeriferous() { return aeriferous; }
+        void set_aeriferous(nlohmann::json const & value) { this->aeriferous = value; }
+
+        nlohmann::json const & get_antical() const { return antical; }
+        nlohmann::json & get_mutable_antical() { return antical; }
+        void set_antical(nlohmann::json const & value) { this->antical = value; }
+
+        nlohmann::json const & get_antighostism() const { return antighostism; }
+        nlohmann::json & get_mutable_antighostism() { return antighostism; }
+        void set_antighostism(nlohmann::json const & value) { this->antighostism = value; }
+
+        nlohmann::json const & get_arcanum() const { return arcanum; }
+        nlohmann::json & get_mutable_arcanum() { return arcanum; }
+        void set_arcanum(nlohmann::json const & value) { this->arcanum = value; }
+
+        nlohmann::json const & get_autotrophy() const { return autotrophy; }
+        nlohmann::json & get_mutable_autotrophy() { return autotrophy; }
+        void set_autotrophy(nlohmann::json const & value) { this->autotrophy = value; }
+
+        nlohmann::json const & get_baronial() const { return baronial; }
+        nlohmann::json & get_mutable_baronial() { return baronial; }
+        void set_baronial(nlohmann::json const & value) { this->baronial = value; }
+
+        nlohmann::json const & get_caffeine() const { return caffeine; }
+        nlohmann::json & get_mutable_caffeine() { return caffeine; }
+        void set_caffeine(nlohmann::json const & value) { this->caffeine = value; }
+
+        nlohmann::json const & get_gorgoniacean() const { return gorgoniacean; }
+        nlohmann::json & get_mutable_gorgoniacean() { return gorgoniacean; }
+        void set_gorgoniacean(nlohmann::json const & value) { this->gorgoniacean = value; }
+
+        nlohmann::json const & get_heroical() const { return heroical; }
+        nlohmann::json & get_mutable_heroical() { return heroical; }
+        void set_heroical(nlohmann::json const & value) { this->heroical = value; }
+
+        nlohmann::json const & get_hydropical() const { return hydropical; }
+        nlohmann::json & get_mutable_hydropical() { return hydropical; }
+        void set_hydropical(nlohmann::json const & value) { this->hydropical = value; }
+
+        nlohmann::json const & get_mechanology() const { return mechanology; }
+        nlohmann::json & get_mutable_mechanology() { return mechanology; }
+        void set_mechanology(nlohmann::json const & value) { this->mechanology = value; }
+
+        nlohmann::json const & get_musicopoetic() const { return musicopoetic; }
+        nlohmann::json & get_mutable_musicopoetic() { return musicopoetic; }
+        void set_musicopoetic(nlohmann::json const & value) { this->musicopoetic = value; }
+
+        nlohmann::json const & get_officiality() const { return officiality; }
+        nlohmann::json & get_mutable_officiality() { return officiality; }
+        void set_officiality(nlohmann::json const & value) { this->officiality = value; }
+
+        nlohmann::json const & get_oftentimes() const { return oftentimes; }
+        nlohmann::json & get_mutable_oftentimes() { return oftentimes; }
+        void set_oftentimes(nlohmann::json const & value) { this->oftentimes = value; }
+
+        nlohmann::json const & get_ophthalmotonometer() const { return ophthalmotonometer; }
+        nlohmann::json & get_mutable_ophthalmotonometer() { return ophthalmotonometer; }
+        void set_ophthalmotonometer(nlohmann::json const & value) { this->ophthalmotonometer = value; }
+
+        nlohmann::json const & get_reflectively() const { return reflectively; }
+        nlohmann::json & get_mutable_reflectively() { return reflectively; }
+        void set_reflectively(nlohmann::json const & value) { this->reflectively = value; }
+
+        nlohmann::json const & get_springer() const { return springer; }
+        nlohmann::json & get_mutable_springer() { return springer; }
+        void set_springer(nlohmann::json const & value) { this->springer = value; }
+
+        nlohmann::json const & get_tabasco() const { return tabasco; }
+        nlohmann::json & get_mutable_tabasco() { return tabasco; }
+        void set_tabasco(nlohmann::json const & value) { this->tabasco = value; }
+
+        nlohmann::json const & get_teleianthous() const { return teleianthous; }
+        nlohmann::json & get_mutable_teleianthous() { return teleianthous; }
+        void set_teleianthous(nlohmann::json const & value) { this->teleianthous = value; }
+
+        nlohmann::json const & get_uncombated() const { return uncombated; }
+        nlohmann::json & get_mutable_uncombated() { return uncombated; }
+        void set_uncombated(nlohmann::json const & value) { this->uncombated = value; }
+    };
+
+    using Scoffer = std::optional<std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>>>;
+
+    using Scrampum = std::optional<std::variant<std::vector<int64_t>, bool>>;
+
+    using Serpentinic = std::variant<std::vector<int64_t>, double>;
+
+    using Shadowable = std::variant<std::vector<std::optional<int64_t>>, bool>;
+
+    class SisteringClass {
+        public:
+        SisteringClass() = default;
+        virtual ~SisteringClass() = default;
+
+        private:
+        nlohmann::json amphicarpic;
+        nlohmann::json chianti;
+        nlohmann::json frigorific;
+        nlohmann::json haplomi;
+        nlohmann::json hyperkinesis;
+        nlohmann::json laudable;
+        nlohmann::json madwoman;
+        nlohmann::json maimedly;
+        nlohmann::json micropterygidae;
+        nlohmann::json microrhabdus;
+        nlohmann::json nondense;
+        nlohmann::json phlebemphraxis;
+        nlohmann::json redsear;
+        nlohmann::json schismatical;
+        nlohmann::json tartryl;
+        nlohmann::json unabhorred;
+        nlohmann::json undeliberateness;
+        nlohmann::json unmixable;
+        nlohmann::json untruckling;
+        nlohmann::json vineal;
+
+        public:
+        nlohmann::json const & get_amphicarpic() const { return amphicarpic; }
+        nlohmann::json & get_mutable_amphicarpic() { return amphicarpic; }
+        void set_amphicarpic(nlohmann::json const & value) { this->amphicarpic = value; }
+
+        nlohmann::json const & get_chianti() const { return chianti; }
+        nlohmann::json & get_mutable_chianti() { return chianti; }
+        void set_chianti(nlohmann::json const & value) { this->chianti = value; }
+
+        nlohmann::json const & get_frigorific() const { return frigorific; }
+        nlohmann::json & get_mutable_frigorific() { return frigorific; }
+        void set_frigorific(nlohmann::json const & value) { this->frigorific = value; }
+
+        nlohmann::json const & get_haplomi() const { return haplomi; }
+        nlohmann::json & get_mutable_haplomi() { return haplomi; }
+        void set_haplomi(nlohmann::json const & value) { this->haplomi = value; }
+
+        nlohmann::json const & get_hyperkinesis() const { return hyperkinesis; }
+        nlohmann::json & get_mutable_hyperkinesis() { return hyperkinesis; }
+        void set_hyperkinesis(nlohmann::json const & value) { this->hyperkinesis = value; }
+
+        nlohmann::json const & get_laudable() const { return laudable; }
+        nlohmann::json & get_mutable_laudable() { return laudable; }
+        void set_laudable(nlohmann::json const & value) { this->laudable = value; }
+
+        nlohmann::json const & get_madwoman() const { return madwoman; }
+        nlohmann::json & get_mutable_madwoman() { return madwoman; }
+        void set_madwoman(nlohmann::json const & value) { this->madwoman = value; }
+
+        nlohmann::json const & get_maimedly() const { return maimedly; }
+        nlohmann::json & get_mutable_maimedly() { return maimedly; }
+        void set_maimedly(nlohmann::json const & value) { this->maimedly = value; }
+
+        nlohmann::json const & get_micropterygidae() const { return micropterygidae; }
+        nlohmann::json & get_mutable_micropterygidae() { return micropterygidae; }
+        void set_micropterygidae(nlohmann::json const & value) { this->micropterygidae = value; }
+
+        nlohmann::json const & get_microrhabdus() const { return microrhabdus; }
+        nlohmann::json & get_mutable_microrhabdus() { return microrhabdus; }
+        void set_microrhabdus(nlohmann::json const & value) { this->microrhabdus = value; }
+
+        nlohmann::json const & get_nondense() const { return nondense; }
+        nlohmann::json & get_mutable_nondense() { return nondense; }
+        void set_nondense(nlohmann::json const & value) { this->nondense = value; }
+
+        nlohmann::json const & get_phlebemphraxis() const { return phlebemphraxis; }
+        nlohmann::json & get_mutable_phlebemphraxis() { return phlebemphraxis; }
+        void set_phlebemphraxis(nlohmann::json const & value) { this->phlebemphraxis = value; }
+
+        nlohmann::json const & get_redsear() const { return redsear; }
+        nlohmann::json & get_mutable_redsear() { return redsear; }
+        void set_redsear(nlohmann::json const & value) { this->redsear = value; }
+
+        nlohmann::json const & get_schismatical() const { return schismatical; }
+        nlohmann::json & get_mutable_schismatical() { return schismatical; }
+        void set_schismatical(nlohmann::json const & value) { this->schismatical = value; }
+
+        nlohmann::json const & get_tartryl() const { return tartryl; }
+        nlohmann::json & get_mutable_tartryl() { return tartryl; }
+        void set_tartryl(nlohmann::json const & value) { this->tartryl = value; }
+
+        nlohmann::json const & get_unabhorred() const { return unabhorred; }
+        nlohmann::json & get_mutable_unabhorred() { return unabhorred; }
+        void set_unabhorred(nlohmann::json const & value) { this->unabhorred = value; }
+
+        nlohmann::json const & get_undeliberateness() const { return undeliberateness; }
+        nlohmann::json & get_mutable_undeliberateness() { return undeliberateness; }
+        void set_undeliberateness(nlohmann::json const & value) { this->undeliberateness = value; }
+
+        nlohmann::json const & get_unmixable() const { return unmixable; }
+        nlohmann::json & get_mutable_unmixable() { return unmixable; }
+        void set_unmixable(nlohmann::json const & value) { this->unmixable = value; }
+
+        nlohmann::json const & get_untruckling() const { return untruckling; }
+        nlohmann::json & get_mutable_untruckling() { return untruckling; }
+        void set_untruckling(nlohmann::json const & value) { this->untruckling = value; }
+
+        nlohmann::json const & get_vineal() const { return vineal; }
+        nlohmann::json & get_mutable_vineal() { return vineal; }
+        void set_vineal(nlohmann::json const & value) { this->vineal = value; }
+    };
+
+    using SisteringElement = std::variant<std::vector<nlohmann::json>, SisteringClass, int64_t>;
+
+    class Staghunting {
+        public:
+        Staghunting() = default;
+        virtual ~Staghunting() = default;
+
+        private:
+        std::optional<int64_t> calorimetric;
+        std::optional<int64_t> canid;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ditriglyphic;
+        std::optional<int64_t> floriferousness;
+        std::optional<int64_t> gamelike;
+        std::optional<int64_t> grig;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> interloan;
+        std::optional<int64_t> lithotomy;
+        std::optional<int64_t> loric;
+        std::optional<int64_t> membranocoriaceous;
+        std::optional<int64_t> membranogenic;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> overtrump;
+        std::optional<int64_t> scotino;
+        std::optional<int64_t> seasonable;
+        std::optional<int64_t> sephen;
+        std::optional<int64_t> stigmarioid;
+        std::optional<int64_t> tired;
+        std::optional<int64_t> trifid;
+        std::optional<int64_t> undefeatedly;
+        std::optional<int64_t> ungirlish;
+
+        public:
+        std::optional<int64_t> const & get_calorimetric() const { return calorimetric; }
+        std::optional<int64_t> & get_mutable_calorimetric() { return calorimetric; }
+        void set_calorimetric(std::optional<int64_t> const & value) { this->calorimetric = value; }
+
+        std::optional<int64_t> const & get_canid() const { return canid; }
+        std::optional<int64_t> & get_mutable_canid() { return canid; }
+        void set_canid(std::optional<int64_t> const & value) { this->canid = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_ditriglyphic() const { return ditriglyphic; }
+        std::optional<int64_t> & get_mutable_ditriglyphic() { return ditriglyphic; }
+        void set_ditriglyphic(std::optional<int64_t> const & value) { this->ditriglyphic = value; }
+
+        std::optional<int64_t> const & get_floriferousness() const { return floriferousness; }
+        std::optional<int64_t> & get_mutable_floriferousness() { return floriferousness; }
+        void set_floriferousness(std::optional<int64_t> const & value) { this->floriferousness = value; }
+
+        std::optional<int64_t> const & get_gamelike() const { return gamelike; }
+        std::optional<int64_t> & get_mutable_gamelike() { return gamelike; }
+        void set_gamelike(std::optional<int64_t> const & value) { this->gamelike = value; }
+
+        std::optional<int64_t> const & get_grig() const { return grig; }
+        std::optional<int64_t> & get_mutable_grig() { return grig; }
+        void set_grig(std::optional<int64_t> const & value) { this->grig = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_interloan() const { return interloan; }
+        std::optional<int64_t> & get_mutable_interloan() { return interloan; }
+        void set_interloan(std::optional<int64_t> const & value) { this->interloan = value; }
+
+        std::optional<int64_t> const & get_lithotomy() const { return lithotomy; }
+        std::optional<int64_t> & get_mutable_lithotomy() { return lithotomy; }
+        void set_lithotomy(std::optional<int64_t> const & value) { this->lithotomy = value; }
+
+        std::optional<int64_t> const & get_loric() const { return loric; }
+        std::optional<int64_t> & get_mutable_loric() { return loric; }
+        void set_loric(std::optional<int64_t> const & value) { this->loric = value; }
+
+        std::optional<int64_t> const & get_membranocoriaceous() const { return membranocoriaceous; }
+        std::optional<int64_t> & get_mutable_membranocoriaceous() { return membranocoriaceous; }
+        void set_membranocoriaceous(std::optional<int64_t> const & value) { this->membranocoriaceous = value; }
+
+        std::optional<int64_t> const & get_membranogenic() const { return membranogenic; }
+        std::optional<int64_t> & get_mutable_membranogenic() { return membranogenic; }
+        void set_membranogenic(std::optional<int64_t> const & value) { this->membranogenic = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_overtrump() const { return overtrump; }
+        std::optional<int64_t> & get_mutable_overtrump() { return overtrump; }
+        void set_overtrump(std::optional<int64_t> const & value) { this->overtrump = value; }
+
+        std::optional<int64_t> const & get_scotino() const { return scotino; }
+        std::optional<int64_t> & get_mutable_scotino() { return scotino; }
+        void set_scotino(std::optional<int64_t> const & value) { this->scotino = value; }
+
+        std::optional<int64_t> const & get_seasonable() const { return seasonable; }
+        std::optional<int64_t> & get_mutable_seasonable() { return seasonable; }
+        void set_seasonable(std::optional<int64_t> const & value) { this->seasonable = value; }
+
+        std::optional<int64_t> const & get_sephen() const { return sephen; }
+        std::optional<int64_t> & get_mutable_sephen() { return sephen; }
+        void set_sephen(std::optional<int64_t> const & value) { this->sephen = value; }
+
+        std::optional<int64_t> const & get_stigmarioid() const { return stigmarioid; }
+        std::optional<int64_t> & get_mutable_stigmarioid() { return stigmarioid; }
+        void set_stigmarioid(std::optional<int64_t> const & value) { this->stigmarioid = value; }
+
+        std::optional<int64_t> const & get_tired() const { return tired; }
+        std::optional<int64_t> & get_mutable_tired() { return tired; }
+        void set_tired(std::optional<int64_t> const & value) { this->tired = value; }
+
+        std::optional<int64_t> const & get_trifid() const { return trifid; }
+        std::optional<int64_t> & get_mutable_trifid() { return trifid; }
+        void set_trifid(std::optional<int64_t> const & value) { this->trifid = value; }
+
+        std::optional<int64_t> const & get_undefeatedly() const { return undefeatedly; }
+        std::optional<int64_t> & get_mutable_undefeatedly() { return undefeatedly; }
+        void set_undefeatedly(std::optional<int64_t> const & value) { this->undefeatedly = value; }
+
+        std::optional<int64_t> const & get_ungirlish() const { return ungirlish; }
+        std::optional<int64_t> & get_mutable_ungirlish() { return ungirlish; }
+        void set_ungirlish(std::optional<int64_t> const & value) { this->ungirlish = value; }
+    };
+
+    using Stagmometer = std::variant<std::vector<std::optional<int64_t>>, std::string>;
+
+    using Stimulability = std::variant<bool, int64_t, std::map<std::string, int64_t>>;
+
+    using Strangleable = std::variant<std::vector<nlohmann::json>, double>;
+
+    class StrenuosityClass {
+        public:
+        StrenuosityClass() = default;
+        virtual ~StrenuosityClass() = default;
+
+        private:
+        std::optional<int64_t> bliss;
+        std::optional<int64_t> buccate;
+        std::optional<int64_t> bulletproof;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> crumblingness;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> engagedly;
+        std::optional<int64_t> fightable;
+        std::optional<int64_t> hoariness;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> hypopodium;
+        std::optional<int64_t> luxurist;
+        std::optional<int64_t> mechanician;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> onopordon;
+        std::optional<int64_t> podgily;
+        std::optional<int64_t> reformableness;
+        std::optional<int64_t> scatterbrains;
+        std::optional<int64_t> seminuria;
+        std::optional<int64_t> sodomite;
+        std::optional<int64_t> tramp;
+        std::optional<int64_t> undueness;
+        std::optional<int64_t> worthily;
+        std::optional<int64_t> yankeeist;
+
+        public:
+        std::optional<int64_t> const & get_bliss() const { return bliss; }
+        std::optional<int64_t> & get_mutable_bliss() { return bliss; }
+        void set_bliss(std::optional<int64_t> const & value) { this->bliss = value; }
+
+        std::optional<int64_t> const & get_buccate() const { return buccate; }
+        std::optional<int64_t> & get_mutable_buccate() { return buccate; }
+        void set_buccate(std::optional<int64_t> const & value) { this->buccate = value; }
+
+        std::optional<int64_t> const & get_bulletproof() const { return bulletproof; }
+        std::optional<int64_t> & get_mutable_bulletproof() { return bulletproof; }
+        void set_bulletproof(std::optional<int64_t> const & value) { this->bulletproof = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_crumblingness() const { return crumblingness; }
+        std::optional<int64_t> & get_mutable_crumblingness() { return crumblingness; }
+        void set_crumblingness(std::optional<int64_t> const & value) { this->crumblingness = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_engagedly() const { return engagedly; }
+        std::optional<int64_t> & get_mutable_engagedly() { return engagedly; }
+        void set_engagedly(std::optional<int64_t> const & value) { this->engagedly = value; }
+
+        std::optional<int64_t> const & get_fightable() const { return fightable; }
+        std::optional<int64_t> & get_mutable_fightable() { return fightable; }
+        void set_fightable(std::optional<int64_t> const & value) { this->fightable = value; }
+
+        std::optional<int64_t> const & get_hoariness() const { return hoariness; }
+        std::optional<int64_t> & get_mutable_hoariness() { return hoariness; }
+        void set_hoariness(std::optional<int64_t> const & value) { this->hoariness = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_hypopodium() const { return hypopodium; }
+        std::optional<int64_t> & get_mutable_hypopodium() { return hypopodium; }
+        void set_hypopodium(std::optional<int64_t> const & value) { this->hypopodium = value; }
+
+        std::optional<int64_t> const & get_luxurist() const { return luxurist; }
+        std::optional<int64_t> & get_mutable_luxurist() { return luxurist; }
+        void set_luxurist(std::optional<int64_t> const & value) { this->luxurist = value; }
+
+        std::optional<int64_t> const & get_mechanician() const { return mechanician; }
+        std::optional<int64_t> & get_mutable_mechanician() { return mechanician; }
+        void set_mechanician(std::optional<int64_t> const & value) { this->mechanician = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_onopordon() const { return onopordon; }
+        std::optional<int64_t> & get_mutable_onopordon() { return onopordon; }
+        void set_onopordon(std::optional<int64_t> const & value) { this->onopordon = value; }
+
+        std::optional<int64_t> const & get_podgily() const { return podgily; }
+        std::optional<int64_t> & get_mutable_podgily() { return podgily; }
+        void set_podgily(std::optional<int64_t> const & value) { this->podgily = value; }
+
+        std::optional<int64_t> const & get_reformableness() const { return reformableness; }
+        std::optional<int64_t> & get_mutable_reformableness() { return reformableness; }
+        void set_reformableness(std::optional<int64_t> const & value) { this->reformableness = value; }
+
+        std::optional<int64_t> const & get_scatterbrains() const { return scatterbrains; }
+        std::optional<int64_t> & get_mutable_scatterbrains() { return scatterbrains; }
+        void set_scatterbrains(std::optional<int64_t> const & value) { this->scatterbrains = value; }
+
+        std::optional<int64_t> const & get_seminuria() const { return seminuria; }
+        std::optional<int64_t> & get_mutable_seminuria() { return seminuria; }
+        void set_seminuria(std::optional<int64_t> const & value) { this->seminuria = value; }
+
+        std::optional<int64_t> const & get_sodomite() const { return sodomite; }
+        std::optional<int64_t> & get_mutable_sodomite() { return sodomite; }
+        void set_sodomite(std::optional<int64_t> const & value) { this->sodomite = value; }
+
+        std::optional<int64_t> const & get_tramp() const { return tramp; }
+        std::optional<int64_t> & get_mutable_tramp() { return tramp; }
+        void set_tramp(std::optional<int64_t> const & value) { this->tramp = value; }
+
+        std::optional<int64_t> const & get_undueness() const { return undueness; }
+        std::optional<int64_t> & get_mutable_undueness() { return undueness; }
+        void set_undueness(std::optional<int64_t> const & value) { this->undueness = value; }
+
+        std::optional<int64_t> const & get_worthily() const { return worthily; }
+        std::optional<int64_t> & get_mutable_worthily() { return worthily; }
+        void set_worthily(std::optional<int64_t> const & value) { this->worthily = value; }
+
+        std::optional<int64_t> const & get_yankeeist() const { return yankeeist; }
+        std::optional<int64_t> & get_mutable_yankeeist() { return yankeeist; }
+        void set_yankeeist(std::optional<int64_t> const & value) { this->yankeeist = value; }
+    };
+
+    using StrenuosityElement = std::variant<std::vector<nlohmann::json>, StrenuosityClass>;
+
+    using Tabaxir = std::variant<bool, double>;
+
+    using Talpiform = std::optional<std::variant<QuebrachineClass, double>>;
+
+    using Thwack = std::variant<bool, QuebrachineClass, double>;
+
+    using Tortricine = std::variant<std::vector<std::optional<int64_t>>, QuebrachineClass>;
+
+    class TruantcyClass {
+        public:
+        TruantcyClass() = default;
+        virtual ~TruantcyClass() = default;
+
+        private:
+        nlohmann::json alfiona;
+        nlohmann::json ascaridiasis;
+        nlohmann::json bungey;
+        std::optional<double> catharticalness;
+        nlohmann::json ceroxyle;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json chorology;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enmarble;
+        nlohmann::json epeira;
+        nlohmann::json eurylaimi;
+        nlohmann::json germination;
+        nlohmann::json hallelujah;
+        std::optional<bool> homocerc;
+        nlohmann::json lev;
+        nlohmann::json mouthing;
+        nlohmann::json nonbookish;
+        nlohmann::json philliloo;
+        nlohmann::json planetal;
+        nlohmann::json poney;
+        nlohmann::json punctualist;
+        nlohmann::json returnlessly;
+        nlohmann::json skelder;
+        nlohmann::json windwaywardly;
+        nlohmann::json yuman;
+
+        public:
+        nlohmann::json const & get_alfiona() const { return alfiona; }
+        nlohmann::json & get_mutable_alfiona() { return alfiona; }
+        void set_alfiona(nlohmann::json const & value) { this->alfiona = value; }
+
+        nlohmann::json const & get_ascaridiasis() const { return ascaridiasis; }
+        nlohmann::json & get_mutable_ascaridiasis() { return ascaridiasis; }
+        void set_ascaridiasis(nlohmann::json const & value) { this->ascaridiasis = value; }
+
+        nlohmann::json const & get_bungey() const { return bungey; }
+        nlohmann::json & get_mutable_bungey() { return bungey; }
+        void set_bungey(nlohmann::json const & value) { this->bungey = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        nlohmann::json const & get_ceroxyle() const { return ceroxyle; }
+        nlohmann::json & get_mutable_ceroxyle() { return ceroxyle; }
+        void set_ceroxyle(nlohmann::json const & value) { this->ceroxyle = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        nlohmann::json const & get_chorology() const { return chorology; }
+        nlohmann::json & get_mutable_chorology() { return chorology; }
+        void set_chorology(nlohmann::json const & value) { this->chorology = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        nlohmann::json const & get_enmarble() const { return enmarble; }
+        nlohmann::json & get_mutable_enmarble() { return enmarble; }
+        void set_enmarble(nlohmann::json const & value) { this->enmarble = value; }
+
+        nlohmann::json const & get_epeira() const { return epeira; }
+        nlohmann::json & get_mutable_epeira() { return epeira; }
+        void set_epeira(nlohmann::json const & value) { this->epeira = value; }
+
+        nlohmann::json const & get_eurylaimi() const { return eurylaimi; }
+        nlohmann::json & get_mutable_eurylaimi() { return eurylaimi; }
+        void set_eurylaimi(nlohmann::json const & value) { this->eurylaimi = value; }
+
+        nlohmann::json const & get_germination() const { return germination; }
+        nlohmann::json & get_mutable_germination() { return germination; }
+        void set_germination(nlohmann::json const & value) { this->germination = value; }
+
+        nlohmann::json const & get_hallelujah() const { return hallelujah; }
+        nlohmann::json & get_mutable_hallelujah() { return hallelujah; }
+        void set_hallelujah(nlohmann::json const & value) { this->hallelujah = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        nlohmann::json const & get_lev() const { return lev; }
+        nlohmann::json & get_mutable_lev() { return lev; }
+        void set_lev(nlohmann::json const & value) { this->lev = value; }
+
+        nlohmann::json const & get_mouthing() const { return mouthing; }
+        nlohmann::json & get_mutable_mouthing() { return mouthing; }
+        void set_mouthing(nlohmann::json const & value) { this->mouthing = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        nlohmann::json const & get_philliloo() const { return philliloo; }
+        nlohmann::json & get_mutable_philliloo() { return philliloo; }
+        void set_philliloo(nlohmann::json const & value) { this->philliloo = value; }
+
+        nlohmann::json const & get_planetal() const { return planetal; }
+        nlohmann::json & get_mutable_planetal() { return planetal; }
+        void set_planetal(nlohmann::json const & value) { this->planetal = value; }
+
+        nlohmann::json const & get_poney() const { return poney; }
+        nlohmann::json & get_mutable_poney() { return poney; }
+        void set_poney(nlohmann::json const & value) { this->poney = value; }
+
+        nlohmann::json const & get_punctualist() const { return punctualist; }
+        nlohmann::json & get_mutable_punctualist() { return punctualist; }
+        void set_punctualist(nlohmann::json const & value) { this->punctualist = value; }
+
+        nlohmann::json const & get_returnlessly() const { return returnlessly; }
+        nlohmann::json & get_mutable_returnlessly() { return returnlessly; }
+        void set_returnlessly(nlohmann::json const & value) { this->returnlessly = value; }
+
+        nlohmann::json const & get_skelder() const { return skelder; }
+        nlohmann::json & get_mutable_skelder() { return skelder; }
+        void set_skelder(nlohmann::json const & value) { this->skelder = value; }
+
+        nlohmann::json const & get_windwaywardly() const { return windwaywardly; }
+        nlohmann::json & get_mutable_windwaywardly() { return windwaywardly; }
+        void set_windwaywardly(nlohmann::json const & value) { this->windwaywardly = value; }
+
+        nlohmann::json const & get_yuman() const { return yuman; }
+        nlohmann::json & get_mutable_yuman() { return yuman; }
+        void set_yuman(nlohmann::json const & value) { this->yuman = value; }
+    };
+
+    using TruantcyElement = std::variant<bool, TruantcyClass>;
+
+    using Unbeginning = std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>, std::string>;
+
+    using Undesirability = std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>;
+
+    using Unerasing = std::variant<std::vector<nlohmann::json>, int64_t, std::map<std::string, int64_t>>;
+
+    using Unguentarium = std::optional<std::variant<std::vector<nlohmann::json>, int64_t>>;
+
+    class UnimpeachablyClass {
+        public:
+        UnimpeachablyClass() = default;
+        virtual ~UnimpeachablyClass() = default;
+
+        private:
+        std::optional<int64_t> acerin;
+        std::optional<int64_t> bobadil;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chlorophylligenous;
+        std::optional<int64_t> conversational;
+        std::optional<int64_t> demiowl;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ectorhinal;
+        std::optional<int64_t> gamblesomeness;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> irrorate;
+        std::optional<int64_t> kindergartening;
+        std::optional<int64_t> lateritic;
+        std::optional<int64_t> mespil;
+        std::optional<int64_t> misconfiguration;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> planometry;
+        std::optional<int64_t> quiina;
+        std::optional<int64_t> robert;
+        std::optional<int64_t> rot;
+        std::optional<int64_t> subcinctorium;
+        std::optional<int64_t> tussocker;
+        std::optional<int64_t> ultraproud;
+        std::optional<int64_t> unsuggestedness;
+
+        public:
+        std::optional<int64_t> const & get_acerin() const { return acerin; }
+        std::optional<int64_t> & get_mutable_acerin() { return acerin; }
+        void set_acerin(std::optional<int64_t> const & value) { this->acerin = value; }
+
+        std::optional<int64_t> const & get_bobadil() const { return bobadil; }
+        std::optional<int64_t> & get_mutable_bobadil() { return bobadil; }
+        void set_bobadil(std::optional<int64_t> const & value) { this->bobadil = value; }
+
+        std::optional<double> const & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(std::optional<double> const & value) { this->catharticalness = value; }
+
+        std::optional<int64_t> const & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(std::optional<int64_t> const & value) { this->chirotherium = value; }
+
+        std::optional<int64_t> const & get_chlorophylligenous() const { return chlorophylligenous; }
+        std::optional<int64_t> & get_mutable_chlorophylligenous() { return chlorophylligenous; }
+        void set_chlorophylligenous(std::optional<int64_t> const & value) { this->chlorophylligenous = value; }
+
+        std::optional<int64_t> const & get_conversational() const { return conversational; }
+        std::optional<int64_t> & get_mutable_conversational() { return conversational; }
+        void set_conversational(std::optional<int64_t> const & value) { this->conversational = value; }
+
+        std::optional<int64_t> const & get_demiowl() const { return demiowl; }
+        std::optional<int64_t> & get_mutable_demiowl() { return demiowl; }
+        void set_demiowl(std::optional<int64_t> const & value) { this->demiowl = value; }
+
+        std::optional<std::string> const & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(std::optional<std::string> const & value) { this->disdiapason = value; }
+
+        std::optional<int64_t> const & get_ectorhinal() const { return ectorhinal; }
+        std::optional<int64_t> & get_mutable_ectorhinal() { return ectorhinal; }
+        void set_ectorhinal(std::optional<int64_t> const & value) { this->ectorhinal = value; }
+
+        std::optional<int64_t> const & get_gamblesomeness() const { return gamblesomeness; }
+        std::optional<int64_t> & get_mutable_gamblesomeness() { return gamblesomeness; }
+        void set_gamblesomeness(std::optional<int64_t> const & value) { this->gamblesomeness = value; }
+
+        std::optional<bool> const & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(std::optional<bool> const & value) { this->homocerc = value; }
+
+        std::optional<int64_t> const & get_irrorate() const { return irrorate; }
+        std::optional<int64_t> & get_mutable_irrorate() { return irrorate; }
+        void set_irrorate(std::optional<int64_t> const & value) { this->irrorate = value; }
+
+        std::optional<int64_t> const & get_kindergartening() const { return kindergartening; }
+        std::optional<int64_t> & get_mutable_kindergartening() { return kindergartening; }
+        void set_kindergartening(std::optional<int64_t> const & value) { this->kindergartening = value; }
+
+        std::optional<int64_t> const & get_lateritic() const { return lateritic; }
+        std::optional<int64_t> & get_mutable_lateritic() { return lateritic; }
+        void set_lateritic(std::optional<int64_t> const & value) { this->lateritic = value; }
+
+        std::optional<int64_t> const & get_mespil() const { return mespil; }
+        std::optional<int64_t> & get_mutable_mespil() { return mespil; }
+        void set_mespil(std::optional<int64_t> const & value) { this->mespil = value; }
+
+        std::optional<int64_t> const & get_misconfiguration() const { return misconfiguration; }
+        std::optional<int64_t> & get_mutable_misconfiguration() { return misconfiguration; }
+        void set_misconfiguration(std::optional<int64_t> const & value) { this->misconfiguration = value; }
+
+        nlohmann::json const & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(nlohmann::json const & value) { this->nonbookish = value; }
+
+        std::optional<int64_t> const & get_planometry() const { return planometry; }
+        std::optional<int64_t> & get_mutable_planometry() { return planometry; }
+        void set_planometry(std::optional<int64_t> const & value) { this->planometry = value; }
+
+        std::optional<int64_t> const & get_quiina() const { return quiina; }
+        std::optional<int64_t> & get_mutable_quiina() { return quiina; }
+        void set_quiina(std::optional<int64_t> const & value) { this->quiina = value; }
+
+        std::optional<int64_t> const & get_robert() const { return robert; }
+        std::optional<int64_t> & get_mutable_robert() { return robert; }
+        void set_robert(std::optional<int64_t> const & value) { this->robert = value; }
+
+        std::optional<int64_t> const & get_rot() const { return rot; }
+        std::optional<int64_t> & get_mutable_rot() { return rot; }
+        void set_rot(std::optional<int64_t> const & value) { this->rot = value; }
+
+        std::optional<int64_t> const & get_subcinctorium() const { return subcinctorium; }
+        std::optional<int64_t> & get_mutable_subcinctorium() { return subcinctorium; }
+        void set_subcinctorium(std::optional<int64_t> const & value) { this->subcinctorium = value; }
+
+        std::optional<int64_t> const & get_tussocker() const { return tussocker; }
+        std::optional<int64_t> & get_mutable_tussocker() { return tussocker; }
+        void set_tussocker(std::optional<int64_t> const & value) { this->tussocker = value; }
+
+        std::optional<int64_t> const & get_ultraproud() const { return ultraproud; }
+        std::optional<int64_t> & get_mutable_ultraproud() { return ultraproud; }
+        void set_ultraproud(std::optional<int64_t> const & value) { this->ultraproud = value; }
+
+        std::optional<int64_t> const & get_unsuggestedness() const { return unsuggestedness; }
+        std::optional<int64_t> & get_mutable_unsuggestedness() { return unsuggestedness; }
+        void set_unsuggestedness(std::optional<int64_t> const & value) { this->unsuggestedness = value; }
+    };
+
+    using UnimpeachablyElement = std::variant<bool, UnimpeachablyClass>;
+
+    using Unmortgaged = std::optional<std::variant<double, std::map<std::string, int64_t>>>;
+
+    using Unobstructed = std::optional<std::variant<QuebrachineClass, int64_t>>;
+
+    using Unreceptivity = std::variant<std::vector<nlohmann::json>, int64_t, std::string>;
+
+    using Unsatisfactoriness = std::variant<std::vector<int64_t>, bool, int64_t>;
+
+    class UnstressedClass {
+        public:
+        UnstressedClass() = default;
+        virtual ~UnstressedClass() = default;
+
+        private:
+        nlohmann::json alain;
+        nlohmann::json amphirhina;
+        nlohmann::json antimachinery;
+        nlohmann::json coldish;
+        nlohmann::json crantara;
+        nlohmann::json distinguishing;
+        nlohmann::json elytroposis;
+        nlohmann::json gentianwort;
+        nlohmann::json heliosis;
+        nlohmann::json instrumental;
+        nlohmann::json introinflection;
+        nlohmann::json kala;
+        nlohmann::json lincolnian;
+        nlohmann::json metad;
+        nlohmann::json sarcophilus;
+        nlohmann::json swingingly;
+        nlohmann::json unconformity;
+        nlohmann::json undecreed;
+        nlohmann::json venerable;
+        nlohmann::json vowellessness;
+
+        public:
+        nlohmann::json const & get_alain() const { return alain; }
+        nlohmann::json & get_mutable_alain() { return alain; }
+        void set_alain(nlohmann::json const & value) { this->alain = value; }
+
+        nlohmann::json const & get_amphirhina() const { return amphirhina; }
+        nlohmann::json & get_mutable_amphirhina() { return amphirhina; }
+        void set_amphirhina(nlohmann::json const & value) { this->amphirhina = value; }
+
+        nlohmann::json const & get_antimachinery() const { return antimachinery; }
+        nlohmann::json & get_mutable_antimachinery() { return antimachinery; }
+        void set_antimachinery(nlohmann::json const & value) { this->antimachinery = value; }
+
+        nlohmann::json const & get_coldish() const { return coldish; }
+        nlohmann::json & get_mutable_coldish() { return coldish; }
+        void set_coldish(nlohmann::json const & value) { this->coldish = value; }
+
+        nlohmann::json const & get_crantara() const { return crantara; }
+        nlohmann::json & get_mutable_crantara() { return crantara; }
+        void set_crantara(nlohmann::json const & value) { this->crantara = value; }
+
+        nlohmann::json const & get_distinguishing() const { return distinguishing; }
+        nlohmann::json & get_mutable_distinguishing() { return distinguishing; }
+        void set_distinguishing(nlohmann::json const & value) { this->distinguishing = value; }
+
+        nlohmann::json const & get_elytroposis() const { return elytroposis; }
+        nlohmann::json & get_mutable_elytroposis() { return elytroposis; }
+        void set_elytroposis(nlohmann::json const & value) { this->elytroposis = value; }
+
+        nlohmann::json const & get_gentianwort() const { return gentianwort; }
+        nlohmann::json & get_mutable_gentianwort() { return gentianwort; }
+        void set_gentianwort(nlohmann::json const & value) { this->gentianwort = value; }
+
+        nlohmann::json const & get_heliosis() const { return heliosis; }
+        nlohmann::json & get_mutable_heliosis() { return heliosis; }
+        void set_heliosis(nlohmann::json const & value) { this->heliosis = value; }
+
+        nlohmann::json const & get_instrumental() const { return instrumental; }
+        nlohmann::json & get_mutable_instrumental() { return instrumental; }
+        void set_instrumental(nlohmann::json const & value) { this->instrumental = value; }
+
+        nlohmann::json const & get_introinflection() const { return introinflection; }
+        nlohmann::json & get_mutable_introinflection() { return introinflection; }
+        void set_introinflection(nlohmann::json const & value) { this->introinflection = value; }
+
+        nlohmann::json const & get_kala() const { return kala; }
+        nlohmann::json & get_mutable_kala() { return kala; }
+        void set_kala(nlohmann::json const & value) { this->kala = value; }
+
+        nlohmann::json const & get_lincolnian() const { return lincolnian; }
+        nlohmann::json & get_mutable_lincolnian() { return lincolnian; }
+        void set_lincolnian(nlohmann::json const & value) { this->lincolnian = value; }
+
+        nlohmann::json const & get_metad() const { return metad; }
+        nlohmann::json & get_mutable_metad() { return metad; }
+        void set_metad(nlohmann::json const & value) { this->metad = value; }
+
+        nlohmann::json const & get_sarcophilus() const { return sarcophilus; }
+        nlohmann::json & get_mutable_sarcophilus() { return sarcophilus; }
+        void set_sarcophilus(nlohmann::json const & value) { this->sarcophilus = value; }
+
+        nlohmann::json const & get_swingingly() const { return swingingly; }
+        nlohmann::json & get_mutable_swingingly() { return swingingly; }
+        void set_swingingly(nlohmann::json const & value) { this->swingingly = value; }
+
+        nlohmann::json const & get_unconformity() const { return unconformity; }
+        nlohmann::json & get_mutable_unconformity() { return unconformity; }
+        void set_unconformity(nlohmann::json const & value) { this->unconformity = value; }
+
+        nlohmann::json const & get_undecreed() const { return undecreed; }
+        nlohmann::json & get_mutable_undecreed() { return undecreed; }
+        void set_undecreed(nlohmann::json const & value) { this->undecreed = value; }
+
+        nlohmann::json const & get_venerable() const { return venerable; }
+        nlohmann::json & get_mutable_venerable() { return venerable; }
+        void set_venerable(nlohmann::json const & value) { this->venerable = value; }
+
+        nlohmann::json const & get_vowellessness() const { return vowellessness; }
+        nlohmann::json & get_mutable_vowellessness() { return vowellessness; }
+        void set_vowellessness(nlohmann::json const & value) { this->vowellessness = value; }
+    };
+
+    using UnstressedElement = std::variant<bool, UnstressedClass, std::string>;
+
+    using Untasked = std::variant<std::vector<nlohmann::json>, double, std::map<std::string, int64_t>>;
+
+    using Unvarying = std::variant<bool, double, std::map<std::string, int64_t>>;
+
+    using Vehemently = std::optional<std::variant<std::vector<nlohmann::json>, bool>>;
+
+    using Whitepot = std::variant<QuebrachineClass, double>;
+
+    class WrothyClass {
+        public:
+        WrothyClass() = default;
+        virtual ~WrothyClass() = default;
+
+        private:
+        nlohmann::json aeschynanthus;
+        nlohmann::json aquiferous;
+        nlohmann::json cheapener;
+        nlohmann::json enumeration;
+        nlohmann::json ephesine;
+        nlohmann::json escadrille;
+        nlohmann::json estrous;
+        nlohmann::json interestedly;
+        nlohmann::json katakinetomer;
+        nlohmann::json mortification;
+        nlohmann::json morula;
+        nlohmann::json orthosymmetrical;
+        nlohmann::json overbark;
+        nlohmann::json politist;
+        nlohmann::json qualified;
+        nlohmann::json sphenomalar;
+        nlohmann::json throatful;
+        nlohmann::json transhumance;
+        nlohmann::json triandrian;
+        nlohmann::json unbooked;
+
+        public:
+        nlohmann::json const & get_aeschynanthus() const { return aeschynanthus; }
+        nlohmann::json & get_mutable_aeschynanthus() { return aeschynanthus; }
+        void set_aeschynanthus(nlohmann::json const & value) { this->aeschynanthus = value; }
+
+        nlohmann::json const & get_aquiferous() const { return aquiferous; }
+        nlohmann::json & get_mutable_aquiferous() { return aquiferous; }
+        void set_aquiferous(nlohmann::json const & value) { this->aquiferous = value; }
+
+        nlohmann::json const & get_cheapener() const { return cheapener; }
+        nlohmann::json & get_mutable_cheapener() { return cheapener; }
+        void set_cheapener(nlohmann::json const & value) { this->cheapener = value; }
+
+        nlohmann::json const & get_enumeration() const { return enumeration; }
+        nlohmann::json & get_mutable_enumeration() { return enumeration; }
+        void set_enumeration(nlohmann::json const & value) { this->enumeration = value; }
+
+        nlohmann::json const & get_ephesine() const { return ephesine; }
+        nlohmann::json & get_mutable_ephesine() { return ephesine; }
+        void set_ephesine(nlohmann::json const & value) { this->ephesine = value; }
+
+        nlohmann::json const & get_escadrille() const { return escadrille; }
+        nlohmann::json & get_mutable_escadrille() { return escadrille; }
+        void set_escadrille(nlohmann::json const & value) { this->escadrille = value; }
+
+        nlohmann::json const & get_estrous() const { return estrous; }
+        nlohmann::json & get_mutable_estrous() { return estrous; }
+        void set_estrous(nlohmann::json const & value) { this->estrous = value; }
+
+        nlohmann::json const & get_interestedly() const { return interestedly; }
+        nlohmann::json & get_mutable_interestedly() { return interestedly; }
+        void set_interestedly(nlohmann::json const & value) { this->interestedly = value; }
+
+        nlohmann::json const & get_katakinetomer() const { return katakinetomer; }
+        nlohmann::json & get_mutable_katakinetomer() { return katakinetomer; }
+        void set_katakinetomer(nlohmann::json const & value) { this->katakinetomer = value; }
+
+        nlohmann::json const & get_mortification() const { return mortification; }
+        nlohmann::json & get_mutable_mortification() { return mortification; }
+        void set_mortification(nlohmann::json const & value) { this->mortification = value; }
+
+        nlohmann::json const & get_morula() const { return morula; }
+        nlohmann::json & get_mutable_morula() { return morula; }
+        void set_morula(nlohmann::json const & value) { this->morula = value; }
+
+        nlohmann::json const & get_orthosymmetrical() const { return orthosymmetrical; }
+        nlohmann::json & get_mutable_orthosymmetrical() { return orthosymmetrical; }
+        void set_orthosymmetrical(nlohmann::json const & value) { this->orthosymmetrical = value; }
+
+        nlohmann::json const & get_overbark() const { return overbark; }
+        nlohmann::json & get_mutable_overbark() { return overbark; }
+        void set_overbark(nlohmann::json const & value) { this->overbark = value; }
+
+        nlohmann::json const & get_politist() const { return politist; }
+        nlohmann::json & get_mutable_politist() { return politist; }
+        void set_politist(nlohmann::json const & value) { this->politist = value; }
+
+        nlohmann::json const & get_qualified() const { return qualified; }
+        nlohmann::json & get_mutable_qualified() { return qualified; }
+        void set_qualified(nlohmann::json const & value) { this->qualified = value; }
+
+        nlohmann::json const & get_sphenomalar() const { return sphenomalar; }
+        nlohmann::json & get_mutable_sphenomalar() { return sphenomalar; }
+        void set_sphenomalar(nlohmann::json const & value) { this->sphenomalar = value; }
+
+        nlohmann::json const & get_throatful() const { return throatful; }
+        nlohmann::json & get_mutable_throatful() { return throatful; }
+        void set_throatful(nlohmann::json const & value) { this->throatful = value; }
+
+        nlohmann::json const & get_transhumance() const { return transhumance; }
+        nlohmann::json & get_mutable_transhumance() { return transhumance; }
+        void set_transhumance(nlohmann::json const & value) { this->transhumance = value; }
+
+        nlohmann::json const & get_triandrian() const { return triandrian; }
+        nlohmann::json & get_mutable_triandrian() { return triandrian; }
+        void set_triandrian(nlohmann::json const & value) { this->triandrian = value; }
+
+        nlohmann::json const & get_unbooked() const { return unbooked; }
+        nlohmann::json & get_mutable_unbooked() { return unbooked; }
+        void set_unbooked(nlohmann::json const & value) { this->unbooked = value; }
+    };
+
+    using WrothyElement = std::variant<std::vector<nlohmann::json>, WrothyClass>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::vector<Protrusive> protrusive;
+        std::vector<PulpitismElement> pulpitism;
+        std::vector<PyodermiaElement> pyodermia;
+        std::vector<QuebrachineElement> quebrachine;
+        std::vector<Querier> querier;
+        std::vector<Rebarbative> rebarbative;
+        std::vector<Reimagine> reimagine;
+        Ressaut ressaut;
+        std::vector<Retrocervical> retrocervical;
+        std::vector<Revert> revert;
+        std::vector<RewriteElement> rewrite;
+        std::vector<Saccoderm> saccoderm;
+        std::vector<SantirElement> santir;
+        std::vector<Saprophilous> saprophilous;
+        std::vector<SaxtenElement> saxten;
+        std::vector<std::optional<Scatty>> scatty;
+        std::vector<Scoffer> scoffer;
+        std::vector<Scrampum> scrampum;
+        double semantic;
+        std::vector<Serpentinic> serpentinic;
+        std::vector<Shadowable> shadowable;
+        std::vector<SisteringElement> sistering;
+        std::vector<Staghunting> staghunting;
+        std::vector<Stagmometer> stagmometer;
+        std::vector<Stimulability> stimulability;
+        std::vector<Strangleable> strangleable;
+        std::vector<StrenuosityElement> strenuosity;
+        std::vector<Tabaxir> tabaxir;
+        std::vector<Talpiform> talpiform;
+        std::vector<Thwack> thwack;
+        std::vector<std::optional<double>> to;
+        std::vector<Tortricine> tortricine;
+        std::vector<TruantcyElement> truantcy;
+        std::vector<std::string> turgesce;
+        std::vector<Unbeginning> unbeginning;
+        std::vector<double> underdunged;
+        std::vector<Undesirability> undesirability;
+        std::vector<Unerasing> unerasing;
+        std::vector<Unguentarium> unguentarium;
+        std::vector<UnimpeachablyElement> unimpeachably;
+        std::vector<Unmortgaged> unmortgaged;
+        std::vector<Unobstructed> unobstructed;
+        std::vector<Unreceptivity> unreceptivity;
+        std::vector<Unsatisfactoriness> unsatisfactoriness;
+        std::vector<int64_t> unsecurity;
+        std::vector<UnstressedElement> unstressed;
+        std::vector<Untasked> untasked;
+        std::vector<Unvarying> unvarying;
+        std::vector<Vehemently> vehemently;
+        std::map<std::string, bool> warriorship;
+        std::vector<Whitepot> whitepot;
+        std::vector<WrothyElement> wrothy;
+
+        public:
+        std::vector<Protrusive> const & get_protrusive() const { return protrusive; }
+        std::vector<Protrusive> & get_mutable_protrusive() { return protrusive; }
+        void set_protrusive(std::vector<Protrusive> const & value) { this->protrusive = value; }
+
+        std::vector<PulpitismElement> const & get_pulpitism() const { return pulpitism; }
+        std::vector<PulpitismElement> & get_mutable_pulpitism() { return pulpitism; }
+        void set_pulpitism(std::vector<PulpitismElement> const & value) { this->pulpitism = value; }
+
+        std::vector<PyodermiaElement> const & get_pyodermia() const { return pyodermia; }
+        std::vector<PyodermiaElement> & get_mutable_pyodermia() { return pyodermia; }
+        void set_pyodermia(std::vector<PyodermiaElement> const & value) { this->pyodermia = value; }
+
+        std::vector<QuebrachineElement> const & get_quebrachine() const { return quebrachine; }
+        std::vector<QuebrachineElement> & get_mutable_quebrachine() { return quebrachine; }
+        void set_quebrachine(std::vector<QuebrachineElement> const & value) { this->quebrachine = value; }
+
+        std::vector<Querier> const & get_querier() const { return querier; }
+        std::vector<Querier> & get_mutable_querier() { return querier; }
+        void set_querier(std::vector<Querier> const & value) { this->querier = value; }
+
+        std::vector<Rebarbative> const & get_rebarbative() const { return rebarbative; }
+        std::vector<Rebarbative> & get_mutable_rebarbative() { return rebarbative; }
+        void set_rebarbative(std::vector<Rebarbative> const & value) { this->rebarbative = value; }
+
+        std::vector<Reimagine> const & get_reimagine() const { return reimagine; }
+        std::vector<Reimagine> & get_mutable_reimagine() { return reimagine; }
+        void set_reimagine(std::vector<Reimagine> const & value) { this->reimagine = value; }
+
+        Ressaut const & get_ressaut() const { return ressaut; }
+        Ressaut & get_mutable_ressaut() { return ressaut; }
+        void set_ressaut(Ressaut const & value) { this->ressaut = value; }
+
+        std::vector<Retrocervical> const & get_retrocervical() const { return retrocervical; }
+        std::vector<Retrocervical> & get_mutable_retrocervical() { return retrocervical; }
+        void set_retrocervical(std::vector<Retrocervical> const & value) { this->retrocervical = value; }
+
+        std::vector<Revert> const & get_revert() const { return revert; }
+        std::vector<Revert> & get_mutable_revert() { return revert; }
+        void set_revert(std::vector<Revert> const & value) { this->revert = value; }
+
+        std::vector<RewriteElement> const & get_rewrite() const { return rewrite; }
+        std::vector<RewriteElement> & get_mutable_rewrite() { return rewrite; }
+        void set_rewrite(std::vector<RewriteElement> const & value) { this->rewrite = value; }
+
+        std::vector<Saccoderm> const & get_saccoderm() const { return saccoderm; }
+        std::vector<Saccoderm> & get_mutable_saccoderm() { return saccoderm; }
+        void set_saccoderm(std::vector<Saccoderm> const & value) { this->saccoderm = value; }
+
+        std::vector<SantirElement> const & get_santir() const { return santir; }
+        std::vector<SantirElement> & get_mutable_santir() { return santir; }
+        void set_santir(std::vector<SantirElement> const & value) { this->santir = value; }
+
+        std::vector<Saprophilous> const & get_saprophilous() const { return saprophilous; }
+        std::vector<Saprophilous> & get_mutable_saprophilous() { return saprophilous; }
+        void set_saprophilous(std::vector<Saprophilous> const & value) { this->saprophilous = value; }
+
+        std::vector<SaxtenElement> const & get_saxten() const { return saxten; }
+        std::vector<SaxtenElement> & get_mutable_saxten() { return saxten; }
+        void set_saxten(std::vector<SaxtenElement> const & value) { this->saxten = value; }
+
+        std::vector<std::optional<Scatty>> const & get_scatty() const { return scatty; }
+        std::vector<std::optional<Scatty>> & get_mutable_scatty() { return scatty; }
+        void set_scatty(std::vector<std::optional<Scatty>> const & value) { this->scatty = value; }
+
+        std::vector<Scoffer> const & get_scoffer() const { return scoffer; }
+        std::vector<Scoffer> & get_mutable_scoffer() { return scoffer; }
+        void set_scoffer(std::vector<Scoffer> const & value) { this->scoffer = value; }
+
+        std::vector<Scrampum> const & get_scrampum() const { return scrampum; }
+        std::vector<Scrampum> & get_mutable_scrampum() { return scrampum; }
+        void set_scrampum(std::vector<Scrampum> const & value) { this->scrampum = value; }
+
+        double const & get_semantic() const { return semantic; }
+        double & get_mutable_semantic() { return semantic; }
+        void set_semantic(double const & value) { this->semantic = value; }
+
+        std::vector<Serpentinic> const & get_serpentinic() const { return serpentinic; }
+        std::vector<Serpentinic> & get_mutable_serpentinic() { return serpentinic; }
+        void set_serpentinic(std::vector<Serpentinic> const & value) { this->serpentinic = value; }
+
+        std::vector<Shadowable> const & get_shadowable() const { return shadowable; }
+        std::vector<Shadowable> & get_mutable_shadowable() { return shadowable; }
+        void set_shadowable(std::vector<Shadowable> const & value) { this->shadowable = value; }
+
+        std::vector<SisteringElement> const & get_sistering() const { return sistering; }
+        std::vector<SisteringElement> & get_mutable_sistering() { return sistering; }
+        void set_sistering(std::vector<SisteringElement> const & value) { this->sistering = value; }
+
+        std::vector<Staghunting> const & get_staghunting() const { return staghunting; }
+        std::vector<Staghunting> & get_mutable_staghunting() { return staghunting; }
+        void set_staghunting(std::vector<Staghunting> const & value) { this->staghunting = value; }
+
+        std::vector<Stagmometer> const & get_stagmometer() const { return stagmometer; }
+        std::vector<Stagmometer> & get_mutable_stagmometer() { return stagmometer; }
+        void set_stagmometer(std::vector<Stagmometer> const & value) { this->stagmometer = value; }
+
+        std::vector<Stimulability> const & get_stimulability() const { return stimulability; }
+        std::vector<Stimulability> & get_mutable_stimulability() { return stimulability; }
+        void set_stimulability(std::vector<Stimulability> const & value) { this->stimulability = value; }
+
+        std::vector<Strangleable> const & get_strangleable() const { return strangleable; }
+        std::vector<Strangleable> & get_mutable_strangleable() { return strangleable; }
+        void set_strangleable(std::vector<Strangleable> const & value) { this->strangleable = value; }
+
+        std::vector<StrenuosityElement> const & get_strenuosity() const { return strenuosity; }
+        std::vector<StrenuosityElement> & get_mutable_strenuosity() { return strenuosity; }
+        void set_strenuosity(std::vector<StrenuosityElement> const & value) { this->strenuosity = value; }
+
+        std::vector<Tabaxir> const & get_tabaxir() const { return tabaxir; }
+        std::vector<Tabaxir> & get_mutable_tabaxir() { return tabaxir; }
+        void set_tabaxir(std::vector<Tabaxir> const & value) { this->tabaxir = value; }
+
+        std::vector<Talpiform> const & get_talpiform() const { return talpiform; }
+        std::vector<Talpiform> & get_mutable_talpiform() { return talpiform; }
+        void set_talpiform(std::vector<Talpiform> const & value) { this->talpiform = value; }
+
+        std::vector<Thwack> const & get_thwack() const { return thwack; }
+        std::vector<Thwack> & get_mutable_thwack() { return thwack; }
+        void set_thwack(std::vector<Thwack> const & value) { this->thwack = value; }
+
+        std::vector<std::optional<double>> const & get_to() const { return to; }
+        std::vector<std::optional<double>> & get_mutable_to() { return to; }
+        void set_to(std::vector<std::optional<double>> const & value) { this->to = value; }
+
+        std::vector<Tortricine> const & get_tortricine() const { return tortricine; }
+        std::vector<Tortricine> & get_mutable_tortricine() { return tortricine; }
+        void set_tortricine(std::vector<Tortricine> const & value) { this->tortricine = value; }
+
+        std::vector<TruantcyElement> const & get_truantcy() const { return truantcy; }
+        std::vector<TruantcyElement> & get_mutable_truantcy() { return truantcy; }
+        void set_truantcy(std::vector<TruantcyElement> const & value) { this->truantcy = value; }
+
+        std::vector<std::string> const & get_turgesce() const { return turgesce; }
+        std::vector<std::string> & get_mutable_turgesce() { return turgesce; }
+        void set_turgesce(std::vector<std::string> const & value) { this->turgesce = value; }
+
+        std::vector<Unbeginning> const & get_unbeginning() const { return unbeginning; }
+        std::vector<Unbeginning> & get_mutable_unbeginning() { return unbeginning; }
+        void set_unbeginning(std::vector<Unbeginning> const & value) { this->unbeginning = value; }
+
+        std::vector<double> const & get_underdunged() const { return underdunged; }
+        std::vector<double> & get_mutable_underdunged() { return underdunged; }
+        void set_underdunged(std::vector<double> const & value) { this->underdunged = value; }
+
+        std::vector<Undesirability> const & get_undesirability() const { return undesirability; }
+        std::vector<Undesirability> & get_mutable_undesirability() { return undesirability; }
+        void set_undesirability(std::vector<Undesirability> const & value) { this->undesirability = value; }
+
+        std::vector<Unerasing> const & get_unerasing() const { return unerasing; }
+        std::vector<Unerasing> & get_mutable_unerasing() { return unerasing; }
+        void set_unerasing(std::vector<Unerasing> const & value) { this->unerasing = value; }
+
+        std::vector<Unguentarium> const & get_unguentarium() const { return unguentarium; }
+        std::vector<Unguentarium> & get_mutable_unguentarium() { return unguentarium; }
+        void set_unguentarium(std::vector<Unguentarium> const & value) { this->unguentarium = value; }
+
+        std::vector<UnimpeachablyElement> const & get_unimpeachably() const { return unimpeachably; }
+        std::vector<UnimpeachablyElement> & get_mutable_unimpeachably() { return unimpeachably; }
+        void set_unimpeachably(std::vector<UnimpeachablyElement> const & value) { this->unimpeachably = value; }
+
+        std::vector<Unmortgaged> const & get_unmortgaged() const { return unmortgaged; }
+        std::vector<Unmortgaged> & get_mutable_unmortgaged() { return unmortgaged; }
+        void set_unmortgaged(std::vector<Unmortgaged> const & value) { this->unmortgaged = value; }
+
+        std::vector<Unobstructed> const & get_unobstructed() const { return unobstructed; }
+        std::vector<Unobstructed> & get_mutable_unobstructed() { return unobstructed; }
+        void set_unobstructed(std::vector<Unobstructed> const & value) { this->unobstructed = value; }
+
+        std::vector<Unreceptivity> const & get_unreceptivity() const { return unreceptivity; }
+        std::vector<Unreceptivity> & get_mutable_unreceptivity() { return unreceptivity; }
+        void set_unreceptivity(std::vector<Unreceptivity> const & value) { this->unreceptivity = value; }
+
+        std::vector<Unsatisfactoriness> const & get_unsatisfactoriness() const { return unsatisfactoriness; }
+        std::vector<Unsatisfactoriness> & get_mutable_unsatisfactoriness() { return unsatisfactoriness; }
+        void set_unsatisfactoriness(std::vector<Unsatisfactoriness> const & value) { this->unsatisfactoriness = value; }
+
+        std::vector<int64_t> const & get_unsecurity() const { return unsecurity; }
+        std::vector<int64_t> & get_mutable_unsecurity() { return unsecurity; }
+        void set_unsecurity(std::vector<int64_t> const & value) { this->unsecurity = value; }
+
+        std::vector<UnstressedElement> const & get_unstressed() const { return unstressed; }
+        std::vector<UnstressedElement> & get_mutable_unstressed() { return unstressed; }
+        void set_unstressed(std::vector<UnstressedElement> const & value) { this->unstressed = value; }
+
+        std::vector<Untasked> const & get_untasked() const { return untasked; }
+        std::vector<Untasked> & get_mutable_untasked() { return untasked; }
+        void set_untasked(std::vector<Untasked> const & value) { this->untasked = value; }
+
+        std::vector<Unvarying> const & get_unvarying() const { return unvarying; }
+        std::vector<Unvarying> & get_mutable_unvarying() { return unvarying; }
+        void set_unvarying(std::vector<Unvarying> const & value) { this->unvarying = value; }
+
+        std::vector<Vehemently> const & get_vehemently() const { return vehemently; }
+        std::vector<Vehemently> & get_mutable_vehemently() { return vehemently; }
+        void set_vehemently(std::vector<Vehemently> const & value) { this->vehemently = value; }
+
+        std::map<std::string, bool> const & get_warriorship() const { return warriorship; }
+        std::map<std::string, bool> & get_mutable_warriorship() { return warriorship; }
+        void set_warriorship(std::map<std::string, bool> const & value) { this->warriorship = value; }
+
+        std::vector<Whitepot> const & get_whitepot() const { return whitepot; }
+        std::vector<Whitepot> & get_mutable_whitepot() { return whitepot; }
+        void set_whitepot(std::vector<Whitepot> const & value) { this->whitepot = value; }
+
+        std::vector<WrothyElement> const & get_wrothy() const { return wrothy; }
+        std::vector<WrothyElement> & get_mutable_wrothy() { return wrothy; }
+        void set_wrothy(std::vector<WrothyElement> const & value) { this->wrothy = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(json const & j, PulpitismClass & x);
+void to_json(json & j, PulpitismClass const & x);
+
+void from_json(json const & j, PyodermiaClass & x);
+void to_json(json & j, PyodermiaClass const & x);
+
+void from_json(json const & j, QuebrachineClass & x);
+void to_json(json & j, QuebrachineClass const & x);
+
+void from_json(json const & j, Reimagine & x);
+void to_json(json & j, Reimagine const & x);
+
+void from_json(json const & j, Ressaut & x);
+void to_json(json & j, Ressaut const & x);
+
+void from_json(json const & j, RewriteClass & x);
+void to_json(json & j, RewriteClass const & x);
+
+void from_json(json const & j, SantirClass & x);
+void to_json(json & j, SantirClass const & x);
+
+void from_json(json const & j, SaxtenClass & x);
+void to_json(json & j, SaxtenClass const & x);
+
+void from_json(json const & j, Scatty & x);
+void to_json(json & j, Scatty const & x);
+
+void from_json(json const & j, SisteringClass & x);
+void to_json(json & j, SisteringClass const & x);
+
+void from_json(json const & j, Staghunting & x);
+void to_json(json & j, Staghunting const & x);
+
+void from_json(json const & j, StrenuosityClass & x);
+void to_json(json & j, StrenuosityClass const & x);
+
+void from_json(json const & j, TruantcyClass & x);
+void to_json(json & j, TruantcyClass const & x);
+
+void from_json(json const & j, UnimpeachablyClass & x);
+void to_json(json & j, UnimpeachablyClass const & x);
+
+void from_json(json const & j, UnstressedClass & x);
+void to_json(json & j, UnstressedClass const & x);
+
+void from_json(json const & j, WrothyClass & x);
+void to_json(json & j, WrothyClass const & x);
+
+void from_json(json const & j, TopLevel & x);
+void to_json(json & j, TopLevel const & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, double> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>> {
+    static void from_json(json const & j, std::variant<quicktype::PyodermiaClass, int64_t> & x);
+    static void to_json(json & j, std::variant<quicktype::PyodermiaClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::QuebrachineClass>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::QuebrachineClass> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::QuebrachineClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<bool, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, double>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool, double> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::string>> {
+    static void from_json(json const & j, std::variant<bool, std::string> & x);
+    static void to_json(json & j, std::variant<bool, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SantirClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::SantirClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::SantirClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SaxtenClass, std::string>> {
+    static void from_json(json const & j, std::variant<quicktype::SaxtenClass, std::string> & x);
+    static void to_json(json & j, std::variant<quicktype::SaxtenClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, bool> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, bool> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, double> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(json const & j, std::variant<bool, double> & x);
+    static void to_json(json & j, std::variant<bool, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::QuebrachineClass, double>> {
+    static void from_json(json const & j, std::variant<quicktype::QuebrachineClass, double> & x);
+    static void to_json(json & j, std::variant<quicktype::QuebrachineClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::QuebrachineClass, double> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::QuebrachineClass, double> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>> {
+    static void from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x);
+    static void to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::TruantcyClass>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::TruantcyClass> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::TruantcyClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::UnimpeachablyClass> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::UnimpeachablyClass> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<double, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>> {
+    static void from_json(json const & j, std::variant<quicktype::QuebrachineClass, int64_t> & x);
+    static void to_json(json & j, std::variant<quicktype::QuebrachineClass, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t, std::string>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, int64_t, std::string> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, int64_t, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>> {
+    static void from_json(json const & j, std::variant<std::vector<int64_t>, bool, int64_t> & x);
+    static void to_json(json & j, std::variant<std::vector<int64_t>, bool, int64_t> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>> {
+    static void from_json(json const & j, std::variant<bool, quicktype::UnstressedClass, std::string> & x);
+    static void to_json(json & j, std::variant<bool, quicktype::UnstressedClass, std::string> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>> {
+    static void from_json(json const & j, std::variant<bool, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, std::variant<bool, double, std::map<std::string, int64_t>> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, bool> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, bool> const & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>> {
+    static void from_json(json const & j, std::variant<std::vector<json>, quicktype::WrothyClass> & x);
+    static void to_json(json & j, std::variant<std::vector<json>, quicktype::WrothyClass> const & x);
+};
+}
+namespace quicktype {
+    inline void from_json(json const & j, PulpitismClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_abnet(get_untyped(j, "abnet"));
+        x.set_buckhorn(get_untyped(j, "buckhorn"));
+        x.set_calciform(get_untyped(j, "calciform"));
+        x.set_chelophore(get_untyped(j, "chelophore"));
+        x.set_cogitation(get_untyped(j, "cogitation"));
+        x.set_decreeable(get_untyped(j, "decreeable"));
+        x.set_despicable(get_untyped(j, "despicable"));
+        x.set_isodiazo(get_untyped(j, "isodiazo"));
+        x.set_jadedly(get_untyped(j, "jadedly"));
+        x.set_leptochlorite(get_untyped(j, "leptochlorite"));
+        x.set_nursling(get_untyped(j, "nursling"));
+        x.set_palamedean(get_untyped(j, "palamedean"));
+        x.set_photoheliograph(get_untyped(j, "photoheliograph"));
+        x.set_pipewood(get_untyped(j, "pipewood"));
+        x.set_roberd(get_untyped(j, "roberd"));
+        x.set_statable(get_untyped(j, "statable"));
+        x.set_superassume(get_untyped(j, "superassume"));
+        x.set_syllabe(get_untyped(j, "syllabe"));
+        x.set_toughhead(get_untyped(j, "toughhead"));
+        x.set_underburn(get_untyped(j, "underburn"));
+    }
+
+    inline void to_json(json & j, PulpitismClass const & x) {
+        j = json::object();
+        j["abnet"] = x.get_abnet();
+        j["buckhorn"] = x.get_buckhorn();
+        j["calciform"] = x.get_calciform();
+        j["chelophore"] = x.get_chelophore();
+        j["cogitation"] = x.get_cogitation();
+        j["decreeable"] = x.get_decreeable();
+        j["despicable"] = x.get_despicable();
+        j["isodiazo"] = x.get_isodiazo();
+        j["jadedly"] = x.get_jadedly();
+        j["leptochlorite"] = x.get_leptochlorite();
+        j["nursling"] = x.get_nursling();
+        j["palamedean"] = x.get_palamedean();
+        j["photoheliograph"] = x.get_photoheliograph();
+        j["pipewood"] = x.get_pipewood();
+        j["roberd"] = x.get_roberd();
+        j["statable"] = x.get_statable();
+        j["superassume"] = x.get_superassume();
+        j["syllabe"] = x.get_syllabe();
+        j["toughhead"] = x.get_toughhead();
+        j["underburn"] = x.get_underburn();
+    }
+
+    inline void from_json(json const & j, PyodermiaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_aphoristically(get_untyped(j, "aphoristically"));
+        x.set_apophyllous(get_untyped(j, "apophyllous"));
+        x.set_cognize(get_untyped(j, "cognize"));
+        x.set_dermonosology(get_untyped(j, "dermonosology"));
+        x.set_gyppo(get_untyped(j, "Gyppo"));
+        x.set_ither(get_untyped(j, "ither"));
+        x.set_juglandaceous(get_untyped(j, "juglandaceous"));
+        x.set_litho(get_untyped(j, "litho"));
+        x.set_macropterous(get_untyped(j, "macropterous"));
+        x.set_photographer(get_untyped(j, "photographer"));
+        x.set_romancing(get_untyped(j, "romancing"));
+        x.set_rumness(get_untyped(j, "rumness"));
+        x.set_somniloquist(get_untyped(j, "somniloquist"));
+        x.set_stressfully(get_untyped(j, "stressfully"));
+        x.set_tactically(get_untyped(j, "tactically"));
+        x.set_tracheophony(get_untyped(j, "tracheophony"));
+        x.set_unappositely(get_untyped(j, "unappositely"));
+        x.set_unclothedly(get_untyped(j, "unclothedly"));
+        x.set_unimplied(get_untyped(j, "unimplied"));
+        x.set_unsyncopated(get_untyped(j, "unsyncopated"));
+    }
+
+    inline void to_json(json & j, PyodermiaClass const & x) {
+        j = json::object();
+        j["aphoristically"] = x.get_aphoristically();
+        j["apophyllous"] = x.get_apophyllous();
+        j["cognize"] = x.get_cognize();
+        j["dermonosology"] = x.get_dermonosology();
+        j["Gyppo"] = x.get_gyppo();
+        j["ither"] = x.get_ither();
+        j["juglandaceous"] = x.get_juglandaceous();
+        j["litho"] = x.get_litho();
+        j["macropterous"] = x.get_macropterous();
+        j["photographer"] = x.get_photographer();
+        j["romancing"] = x.get_romancing();
+        j["rumness"] = x.get_rumness();
+        j["somniloquist"] = x.get_somniloquist();
+        j["stressfully"] = x.get_stressfully();
+        j["tactically"] = x.get_tactically();
+        j["tracheophony"] = x.get_tracheophony();
+        j["unappositely"] = x.get_unappositely();
+        j["unclothedly"] = x.get_unclothedly();
+        j["unimplied"] = x.get_unimplied();
+        j["unsyncopated"] = x.get_unsyncopated();
+    }
+
+    inline void from_json(json const & j, QuebrachineClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, QuebrachineClass const & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(json const & j, Reimagine& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_adducible(get_untyped(j, "adducible"));
+        x.set_anabolin(get_untyped(j, "anabolin"));
+        x.set_brainy(get_untyped(j, "brainy"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chrysamine(get_untyped(j, "chrysamine"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_fluxweed(get_untyped(j, "fluxweed"));
+        x.set_glaucine(get_untyped(j, "glaucine"));
+        x.set_grobianism(get_untyped(j, "grobianism"));
+        x.set_hermo(get_untyped(j, "Hermo"));
+        x.set_hieroglyphist(get_untyped(j, "hieroglyphist"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_icteroid(get_untyped(j, "icteroid"));
+        x.set_immortal(get_untyped(j, "immortal"));
+        x.set_impetulant(get_untyped(j, "impetulant"));
+        x.set_irrigate(get_untyped(j, "irrigate"));
+        x.set_myxedema(get_untyped(j, "myxedema"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_onyx(get_untyped(j, "onyx"));
+        x.set_repasser(get_untyped(j, "repasser"));
+        x.set_septomarginal(get_untyped(j, "septomarginal"));
+        x.set_subdie(get_untyped(j, "subdie"));
+        x.set_tibiometatarsal(get_untyped(j, "tibiometatarsal"));
+        x.set_waltzlike(get_untyped(j, "waltzlike"));
+    }
+
+    inline void to_json(json & j, Reimagine const & x) {
+        j = json::object();
+        j["adducible"] = x.get_adducible();
+        j["anabolin"] = x.get_anabolin();
+        j["brainy"] = x.get_brainy();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chrysamine"] = x.get_chrysamine();
+        j["disdiapason"] = x.get_disdiapason();
+        j["fluxweed"] = x.get_fluxweed();
+        j["glaucine"] = x.get_glaucine();
+        j["grobianism"] = x.get_grobianism();
+        j["Hermo"] = x.get_hermo();
+        j["hieroglyphist"] = x.get_hieroglyphist();
+        j["homocerc"] = x.get_homocerc();
+        j["icteroid"] = x.get_icteroid();
+        j["immortal"] = x.get_immortal();
+        j["impetulant"] = x.get_impetulant();
+        j["irrigate"] = x.get_irrigate();
+        j["myxedema"] = x.get_myxedema();
+        j["nonbookish"] = x.get_nonbookish();
+        j["onyx"] = x.get_onyx();
+        j["repasser"] = x.get_repasser();
+        j["septomarginal"] = x.get_septomarginal();
+        j["subdie"] = x.get_subdie();
+        j["tibiometatarsal"] = x.get_tibiometatarsal();
+        j["waltzlike"] = x.get_waltzlike();
+    }
+
+    inline void from_json(json const & j, Ressaut& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apperceptive(j.at("apperceptive").get<std::string>());
+        x.set_cuttoo(j.at("cuttoo").get<std::string>());
+        x.set_douser(j.at("douser").get<std::string>());
+        x.set_drinkproof(j.at("drinkproof").get<std::string>());
+        x.set_forementioned(j.at("forementioned").get<std::string>());
+        x.set_freesia(j.at("Freesia").get<std::string>());
+        x.set_genevieve(j.at("Genevieve").get<std::string>());
+        x.set_hyperdiabolical(j.at("hyperdiabolical").get<std::string>());
+        x.set_hypocone(j.at("hypocone").get<std::string>());
+        x.set_irreverentially(j.at("irreverentially").get<std::string>());
+        x.set_jumart(j.at("jumart").get<std::string>());
+        x.set_mimosaceae(j.at("Mimosaceae").get<std::string>());
+        x.set_mollicrush(j.at("mollicrush").get<std::string>());
+        x.set_nedder(j.at("nedder").get<std::string>());
+        x.set_retinasphalt(j.at("retinasphalt").get<std::string>());
+        x.set_sough(j.at("sough").get<std::string>());
+        x.set_steading(j.at("steading").get<std::string>());
+        x.set_theopaschitism(j.at("Theopaschitism").get<std::string>());
+        x.set_undurableness(j.at("undurableness").get<std::string>());
+        x.set_unmingleable(j.at("unmingleable").get<std::string>());
+    }
+
+    inline void to_json(json & j, Ressaut const & x) {
+        j = json::object();
+        j["apperceptive"] = x.get_apperceptive();
+        j["cuttoo"] = x.get_cuttoo();
+        j["douser"] = x.get_douser();
+        j["drinkproof"] = x.get_drinkproof();
+        j["forementioned"] = x.get_forementioned();
+        j["Freesia"] = x.get_freesia();
+        j["Genevieve"] = x.get_genevieve();
+        j["hyperdiabolical"] = x.get_hyperdiabolical();
+        j["hypocone"] = x.get_hypocone();
+        j["irreverentially"] = x.get_irreverentially();
+        j["jumart"] = x.get_jumart();
+        j["Mimosaceae"] = x.get_mimosaceae();
+        j["mollicrush"] = x.get_mollicrush();
+        j["nedder"] = x.get_nedder();
+        j["retinasphalt"] = x.get_retinasphalt();
+        j["sough"] = x.get_sough();
+        j["steading"] = x.get_steading();
+        j["Theopaschitism"] = x.get_theopaschitism();
+        j["undurableness"] = x.get_undurableness();
+        j["unmingleable"] = x.get_unmingleable();
+    }
+
+    inline void from_json(json const & j, RewriteClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_accountancy(get_untyped(j, "accountancy"));
+        x.set_cacotrophic(get_untyped(j, "cacotrophic"));
+        x.set_contest(get_untyped(j, "contest"));
+        x.set_couthily(get_untyped(j, "couthily"));
+        x.set_falculate(get_untyped(j, "falculate"));
+        x.set_foreseize(get_untyped(j, "foreseize"));
+        x.set_hyades(get_untyped(j, "Hyades"));
+        x.set_lemnad(get_untyped(j, "lemnad"));
+        x.set_monotheistically(get_untyped(j, "monotheistically"));
+        x.set_nonflying(get_untyped(j, "nonflying"));
+        x.set_ptenoglossa(get_untyped(j, "Ptenoglossa"));
+        x.set_repatch(get_untyped(j, "repatch"));
+        x.set_rodman(get_untyped(j, "rodman"));
+        x.set_strung(get_untyped(j, "strung"));
+        x.set_titmal(get_untyped(j, "titmal"));
+        x.set_twalpennyworth(get_untyped(j, "twalpennyworth"));
+        x.set_unblamable(get_untyped(j, "unblamable"));
+        x.set_vertical(get_untyped(j, "vertical"));
+        x.set_whiggification(get_untyped(j, "Whiggification"));
+        x.set_yardman(get_untyped(j, "yardman"));
+    }
+
+    inline void to_json(json & j, RewriteClass const & x) {
+        j = json::object();
+        j["accountancy"] = x.get_accountancy();
+        j["cacotrophic"] = x.get_cacotrophic();
+        j["contest"] = x.get_contest();
+        j["couthily"] = x.get_couthily();
+        j["falculate"] = x.get_falculate();
+        j["foreseize"] = x.get_foreseize();
+        j["Hyades"] = x.get_hyades();
+        j["lemnad"] = x.get_lemnad();
+        j["monotheistically"] = x.get_monotheistically();
+        j["nonflying"] = x.get_nonflying();
+        j["Ptenoglossa"] = x.get_ptenoglossa();
+        j["repatch"] = x.get_repatch();
+        j["rodman"] = x.get_rodman();
+        j["strung"] = x.get_strung();
+        j["titmal"] = x.get_titmal();
+        j["twalpennyworth"] = x.get_twalpennyworth();
+        j["unblamable"] = x.get_unblamable();
+        j["vertical"] = x.get_vertical();
+        j["Whiggification"] = x.get_whiggification();
+        j["yardman"] = x.get_yardman();
+    }
+
+    inline void from_json(json const & j, SantirClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_admiredly(get_untyped(j, "admiredly"));
+        x.set_demicaponier(get_untyped(j, "demicaponier"));
+        x.set_epitympanic(get_untyped(j, "epitympanic"));
+        x.set_investitor(get_untyped(j, "investitor"));
+        x.set_lupiform(get_untyped(j, "lupiform"));
+        x.set_monoflagellate(get_untyped(j, "monoflagellate"));
+        x.set_paleoethnic(get_untyped(j, "paleoethnic"));
+        x.set_prediscountable(get_untyped(j, "prediscountable"));
+        x.set_rhetoricals(get_untyped(j, "rhetoricals"));
+        x.set_roomth(get_untyped(j, "roomth"));
+        x.set_saccharose(get_untyped(j, "saccharose"));
+        x.set_septonasal(get_untyped(j, "septonasal"));
+        x.set_serpenticide(get_untyped(j, "serpenticide"));
+        x.set_setarious(get_untyped(j, "setarious"));
+        x.set_spaework(get_untyped(j, "spaework"));
+        x.set_stylite(get_untyped(j, "stylite"));
+        x.set_suessiones(get_untyped(j, "Suessiones"));
+        x.set_timelily(get_untyped(j, "timelily"));
+        x.set_unprofaned(get_untyped(j, "unprofaned"));
+        x.set_vorticular(get_untyped(j, "vorticular"));
+    }
+
+    inline void to_json(json & j, SantirClass const & x) {
+        j = json::object();
+        j["admiredly"] = x.get_admiredly();
+        j["demicaponier"] = x.get_demicaponier();
+        j["epitympanic"] = x.get_epitympanic();
+        j["investitor"] = x.get_investitor();
+        j["lupiform"] = x.get_lupiform();
+        j["monoflagellate"] = x.get_monoflagellate();
+        j["paleoethnic"] = x.get_paleoethnic();
+        j["prediscountable"] = x.get_prediscountable();
+        j["rhetoricals"] = x.get_rhetoricals();
+        j["roomth"] = x.get_roomth();
+        j["saccharose"] = x.get_saccharose();
+        j["septonasal"] = x.get_septonasal();
+        j["serpenticide"] = x.get_serpenticide();
+        j["setarious"] = x.get_setarious();
+        j["spaework"] = x.get_spaework();
+        j["stylite"] = x.get_stylite();
+        j["Suessiones"] = x.get_suessiones();
+        j["timelily"] = x.get_timelily();
+        j["unprofaned"] = x.get_unprofaned();
+        j["vorticular"] = x.get_vorticular();
+    }
+
+    inline void from_json(json const & j, SaxtenClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_algarrobilla(get_untyped(j, "algarrobilla"));
+        x.set_bowgrace(get_untyped(j, "bowgrace"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_centaurid(get_untyped(j, "Centaurid"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_flix(get_untyped(j, "flix"));
+        x.set_germanely(get_untyped(j, "germanely"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_inhume(get_untyped(j, "inhume"));
+        x.set_lepidote(get_untyped(j, "lepidote"));
+        x.set_megalochirous(get_untyped(j, "megalochirous"));
+        x.set_ninepenny(get_untyped(j, "ninepenny"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_nondeist(get_untyped(j, "nondeist"));
+        x.set_nymphaeaceous(get_untyped(j, "nymphaeaceous"));
+        x.set_parietofrontal(get_untyped(j, "parietofrontal"));
+        x.set_sancyite(get_untyped(j, "sancyite"));
+        x.set_subjectivist(get_untyped(j, "subjectivist"));
+        x.set_tibiad(get_untyped(j, "tibiad"));
+        x.set_transonic(get_untyped(j, "transonic"));
+        x.set_tripetalous(get_untyped(j, "tripetalous"));
+        x.set_trunchman(get_untyped(j, "trunchman"));
+        x.set_urger(get_untyped(j, "urger"));
+        x.set_withdrawnness(get_untyped(j, "withdrawnness"));
+    }
+
+    inline void to_json(json & j, SaxtenClass const & x) {
+        j = json::object();
+        j["algarrobilla"] = x.get_algarrobilla();
+        j["bowgrace"] = x.get_bowgrace();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Centaurid"] = x.get_centaurid();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["flix"] = x.get_flix();
+        j["germanely"] = x.get_germanely();
+        j["homocerc"] = x.get_homocerc();
+        j["inhume"] = x.get_inhume();
+        j["lepidote"] = x.get_lepidote();
+        j["megalochirous"] = x.get_megalochirous();
+        j["ninepenny"] = x.get_ninepenny();
+        j["nonbookish"] = x.get_nonbookish();
+        j["nondeist"] = x.get_nondeist();
+        j["nymphaeaceous"] = x.get_nymphaeaceous();
+        j["parietofrontal"] = x.get_parietofrontal();
+        j["sancyite"] = x.get_sancyite();
+        j["subjectivist"] = x.get_subjectivist();
+        j["tibiad"] = x.get_tibiad();
+        j["transonic"] = x.get_transonic();
+        j["tripetalous"] = x.get_tripetalous();
+        j["trunchman"] = x.get_trunchman();
+        j["urger"] = x.get_urger();
+        j["withdrawnness"] = x.get_withdrawnness();
+    }
+
+    inline void from_json(json const & j, Scatty& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_aeriferous(get_untyped(j, "aeriferous"));
+        x.set_antical(get_untyped(j, "antical"));
+        x.set_antighostism(get_untyped(j, "antighostism"));
+        x.set_arcanum(get_untyped(j, "arcanum"));
+        x.set_autotrophy(get_untyped(j, "autotrophy"));
+        x.set_baronial(get_untyped(j, "baronial"));
+        x.set_caffeine(get_untyped(j, "caffeine"));
+        x.set_gorgoniacean(get_untyped(j, "gorgoniacean"));
+        x.set_heroical(get_untyped(j, "heroical"));
+        x.set_hydropical(get_untyped(j, "hydropical"));
+        x.set_mechanology(get_untyped(j, "mechanology"));
+        x.set_musicopoetic(get_untyped(j, "musicopoetic"));
+        x.set_officiality(get_untyped(j, "officiality"));
+        x.set_oftentimes(get_untyped(j, "oftentimes"));
+        x.set_ophthalmotonometer(get_untyped(j, "ophthalmotonometer"));
+        x.set_reflectively(get_untyped(j, "reflectively"));
+        x.set_springer(get_untyped(j, "springer"));
+        x.set_tabasco(get_untyped(j, "Tabasco"));
+        x.set_teleianthous(get_untyped(j, "teleianthous"));
+        x.set_uncombated(get_untyped(j, "uncombated"));
+    }
+
+    inline void to_json(json & j, Scatty const & x) {
+        j = json::object();
+        j["aeriferous"] = x.get_aeriferous();
+        j["antical"] = x.get_antical();
+        j["antighostism"] = x.get_antighostism();
+        j["arcanum"] = x.get_arcanum();
+        j["autotrophy"] = x.get_autotrophy();
+        j["baronial"] = x.get_baronial();
+        j["caffeine"] = x.get_caffeine();
+        j["gorgoniacean"] = x.get_gorgoniacean();
+        j["heroical"] = x.get_heroical();
+        j["hydropical"] = x.get_hydropical();
+        j["mechanology"] = x.get_mechanology();
+        j["musicopoetic"] = x.get_musicopoetic();
+        j["officiality"] = x.get_officiality();
+        j["oftentimes"] = x.get_oftentimes();
+        j["ophthalmotonometer"] = x.get_ophthalmotonometer();
+        j["reflectively"] = x.get_reflectively();
+        j["springer"] = x.get_springer();
+        j["Tabasco"] = x.get_tabasco();
+        j["teleianthous"] = x.get_teleianthous();
+        j["uncombated"] = x.get_uncombated();
+    }
+
+    inline void from_json(json const & j, SisteringClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amphicarpic(get_untyped(j, "amphicarpic"));
+        x.set_chianti(get_untyped(j, "Chianti"));
+        x.set_frigorific(get_untyped(j, "frigorific"));
+        x.set_haplomi(get_untyped(j, "Haplomi"));
+        x.set_hyperkinesis(get_untyped(j, "hyperkinesis"));
+        x.set_laudable(get_untyped(j, "laudable"));
+        x.set_madwoman(get_untyped(j, "madwoman"));
+        x.set_maimedly(get_untyped(j, "maimedly"));
+        x.set_micropterygidae(get_untyped(j, "Micropterygidae"));
+        x.set_microrhabdus(get_untyped(j, "microrhabdus"));
+        x.set_nondense(get_untyped(j, "nondense"));
+        x.set_phlebemphraxis(get_untyped(j, "phlebemphraxis"));
+        x.set_redsear(get_untyped(j, "redsear"));
+        x.set_schismatical(get_untyped(j, "schismatical"));
+        x.set_tartryl(get_untyped(j, "tartryl"));
+        x.set_unabhorred(get_untyped(j, "unabhorred"));
+        x.set_undeliberateness(get_untyped(j, "undeliberateness"));
+        x.set_unmixable(get_untyped(j, "unmixable"));
+        x.set_untruckling(get_untyped(j, "untruckling"));
+        x.set_vineal(get_untyped(j, "vineal"));
+    }
+
+    inline void to_json(json & j, SisteringClass const & x) {
+        j = json::object();
+        j["amphicarpic"] = x.get_amphicarpic();
+        j["Chianti"] = x.get_chianti();
+        j["frigorific"] = x.get_frigorific();
+        j["Haplomi"] = x.get_haplomi();
+        j["hyperkinesis"] = x.get_hyperkinesis();
+        j["laudable"] = x.get_laudable();
+        j["madwoman"] = x.get_madwoman();
+        j["maimedly"] = x.get_maimedly();
+        j["Micropterygidae"] = x.get_micropterygidae();
+        j["microrhabdus"] = x.get_microrhabdus();
+        j["nondense"] = x.get_nondense();
+        j["phlebemphraxis"] = x.get_phlebemphraxis();
+        j["redsear"] = x.get_redsear();
+        j["schismatical"] = x.get_schismatical();
+        j["tartryl"] = x.get_tartryl();
+        j["unabhorred"] = x.get_unabhorred();
+        j["undeliberateness"] = x.get_undeliberateness();
+        j["unmixable"] = x.get_unmixable();
+        j["untruckling"] = x.get_untruckling();
+        j["vineal"] = x.get_vineal();
+    }
+
+    inline void from_json(json const & j, Staghunting& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_calorimetric(get_stack_optional<int64_t>(j, "calorimetric"));
+        x.set_canid(get_stack_optional<int64_t>(j, "canid"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ditriglyphic(get_stack_optional<int64_t>(j, "ditriglyphic"));
+        x.set_floriferousness(get_stack_optional<int64_t>(j, "floriferousness"));
+        x.set_gamelike(get_stack_optional<int64_t>(j, "gamelike"));
+        x.set_grig(get_stack_optional<int64_t>(j, "grig"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_interloan(get_stack_optional<int64_t>(j, "interloan"));
+        x.set_lithotomy(get_stack_optional<int64_t>(j, "lithotomy"));
+        x.set_loric(get_stack_optional<int64_t>(j, "loric"));
+        x.set_membranocoriaceous(get_stack_optional<int64_t>(j, "membranocoriaceous"));
+        x.set_membranogenic(get_stack_optional<int64_t>(j, "membranogenic"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_overtrump(get_stack_optional<int64_t>(j, "overtrump"));
+        x.set_scotino(get_stack_optional<int64_t>(j, "scotino"));
+        x.set_seasonable(get_stack_optional<int64_t>(j, "seasonable"));
+        x.set_sephen(get_stack_optional<int64_t>(j, "sephen"));
+        x.set_stigmarioid(get_stack_optional<int64_t>(j, "stigmarioid"));
+        x.set_tired(get_stack_optional<int64_t>(j, "tired"));
+        x.set_trifid(get_stack_optional<int64_t>(j, "trifid"));
+        x.set_undefeatedly(get_stack_optional<int64_t>(j, "undefeatedly"));
+        x.set_ungirlish(get_stack_optional<int64_t>(j, "ungirlish"));
+    }
+
+    inline void to_json(json & j, Staghunting const & x) {
+        j = json::object();
+        j["calorimetric"] = x.get_calorimetric();
+        j["canid"] = x.get_canid();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ditriglyphic"] = x.get_ditriglyphic();
+        j["floriferousness"] = x.get_floriferousness();
+        j["gamelike"] = x.get_gamelike();
+        j["grig"] = x.get_grig();
+        j["homocerc"] = x.get_homocerc();
+        j["interloan"] = x.get_interloan();
+        j["lithotomy"] = x.get_lithotomy();
+        j["loric"] = x.get_loric();
+        j["membranocoriaceous"] = x.get_membranocoriaceous();
+        j["membranogenic"] = x.get_membranogenic();
+        j["nonbookish"] = x.get_nonbookish();
+        j["overtrump"] = x.get_overtrump();
+        j["scotino"] = x.get_scotino();
+        j["seasonable"] = x.get_seasonable();
+        j["sephen"] = x.get_sephen();
+        j["stigmarioid"] = x.get_stigmarioid();
+        j["tired"] = x.get_tired();
+        j["trifid"] = x.get_trifid();
+        j["undefeatedly"] = x.get_undefeatedly();
+        j["ungirlish"] = x.get_ungirlish();
+    }
+
+    inline void from_json(json const & j, StrenuosityClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_bliss(get_stack_optional<int64_t>(j, "bliss"));
+        x.set_buccate(get_stack_optional<int64_t>(j, "buccate"));
+        x.set_bulletproof(get_stack_optional<int64_t>(j, "bulletproof"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_crumblingness(get_stack_optional<int64_t>(j, "crumblingness"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_engagedly(get_stack_optional<int64_t>(j, "engagedly"));
+        x.set_fightable(get_stack_optional<int64_t>(j, "fightable"));
+        x.set_hoariness(get_stack_optional<int64_t>(j, "hoariness"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_hypopodium(get_stack_optional<int64_t>(j, "hypopodium"));
+        x.set_luxurist(get_stack_optional<int64_t>(j, "luxurist"));
+        x.set_mechanician(get_stack_optional<int64_t>(j, "mechanician"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_onopordon(get_stack_optional<int64_t>(j, "Onopordon"));
+        x.set_podgily(get_stack_optional<int64_t>(j, "podgily"));
+        x.set_reformableness(get_stack_optional<int64_t>(j, "reformableness"));
+        x.set_scatterbrains(get_stack_optional<int64_t>(j, "scatterbrains"));
+        x.set_seminuria(get_stack_optional<int64_t>(j, "seminuria"));
+        x.set_sodomite(get_stack_optional<int64_t>(j, "Sodomite"));
+        x.set_tramp(get_stack_optional<int64_t>(j, "tramp"));
+        x.set_undueness(get_stack_optional<int64_t>(j, "undueness"));
+        x.set_worthily(get_stack_optional<int64_t>(j, "worthily"));
+        x.set_yankeeist(get_stack_optional<int64_t>(j, "Yankeeist"));
+    }
+
+    inline void to_json(json & j, StrenuosityClass const & x) {
+        j = json::object();
+        j["bliss"] = x.get_bliss();
+        j["buccate"] = x.get_buccate();
+        j["bulletproof"] = x.get_bulletproof();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["crumblingness"] = x.get_crumblingness();
+        j["disdiapason"] = x.get_disdiapason();
+        j["engagedly"] = x.get_engagedly();
+        j["fightable"] = x.get_fightable();
+        j["hoariness"] = x.get_hoariness();
+        j["homocerc"] = x.get_homocerc();
+        j["hypopodium"] = x.get_hypopodium();
+        j["luxurist"] = x.get_luxurist();
+        j["mechanician"] = x.get_mechanician();
+        j["nonbookish"] = x.get_nonbookish();
+        j["Onopordon"] = x.get_onopordon();
+        j["podgily"] = x.get_podgily();
+        j["reformableness"] = x.get_reformableness();
+        j["scatterbrains"] = x.get_scatterbrains();
+        j["seminuria"] = x.get_seminuria();
+        j["Sodomite"] = x.get_sodomite();
+        j["tramp"] = x.get_tramp();
+        j["undueness"] = x.get_undueness();
+        j["worthily"] = x.get_worthily();
+        j["Yankeeist"] = x.get_yankeeist();
+    }
+
+    inline void from_json(json const & j, TruantcyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alfiona(get_untyped(j, "alfiona"));
+        x.set_ascaridiasis(get_untyped(j, "ascaridiasis"));
+        x.set_bungey(get_untyped(j, "bungey"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_ceroxyle(get_untyped(j, "ceroxyle"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chorology(get_untyped(j, "chorology"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_enmarble(get_untyped(j, "enmarble"));
+        x.set_epeira(get_untyped(j, "Epeira"));
+        x.set_eurylaimi(get_untyped(j, "Eurylaimi"));
+        x.set_germination(get_untyped(j, "germination"));
+        x.set_hallelujah(get_untyped(j, "hallelujah"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_lev(get_untyped(j, "lev"));
+        x.set_mouthing(get_untyped(j, "mouthing"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_philliloo(get_untyped(j, "philliloo"));
+        x.set_planetal(get_untyped(j, "planetal"));
+        x.set_poney(get_untyped(j, "poney"));
+        x.set_punctualist(get_untyped(j, "punctualist"));
+        x.set_returnlessly(get_untyped(j, "returnlessly"));
+        x.set_skelder(get_untyped(j, "skelder"));
+        x.set_windwaywardly(get_untyped(j, "windwaywardly"));
+        x.set_yuman(get_untyped(j, "Yuman"));
+    }
+
+    inline void to_json(json & j, TruantcyClass const & x) {
+        j = json::object();
+        j["alfiona"] = x.get_alfiona();
+        j["ascaridiasis"] = x.get_ascaridiasis();
+        j["bungey"] = x.get_bungey();
+        j["catharticalness"] = x.get_catharticalness();
+        j["ceroxyle"] = x.get_ceroxyle();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chorology"] = x.get_chorology();
+        j["disdiapason"] = x.get_disdiapason();
+        j["enmarble"] = x.get_enmarble();
+        j["Epeira"] = x.get_epeira();
+        j["Eurylaimi"] = x.get_eurylaimi();
+        j["germination"] = x.get_germination();
+        j["hallelujah"] = x.get_hallelujah();
+        j["homocerc"] = x.get_homocerc();
+        j["lev"] = x.get_lev();
+        j["mouthing"] = x.get_mouthing();
+        j["nonbookish"] = x.get_nonbookish();
+        j["philliloo"] = x.get_philliloo();
+        j["planetal"] = x.get_planetal();
+        j["poney"] = x.get_poney();
+        j["punctualist"] = x.get_punctualist();
+        j["returnlessly"] = x.get_returnlessly();
+        j["skelder"] = x.get_skelder();
+        j["windwaywardly"] = x.get_windwaywardly();
+        j["Yuman"] = x.get_yuman();
+    }
+
+    inline void from_json(json const & j, UnimpeachablyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acerin(get_stack_optional<int64_t>(j, "acerin"));
+        x.set_bobadil(get_stack_optional<int64_t>(j, "Bobadil"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chlorophylligenous(get_stack_optional<int64_t>(j, "chlorophylligenous"));
+        x.set_conversational(get_stack_optional<int64_t>(j, "conversational"));
+        x.set_demiowl(get_stack_optional<int64_t>(j, "demiowl"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ectorhinal(get_stack_optional<int64_t>(j, "ectorhinal"));
+        x.set_gamblesomeness(get_stack_optional<int64_t>(j, "gamblesomeness"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_irrorate(get_stack_optional<int64_t>(j, "irrorate"));
+        x.set_kindergartening(get_stack_optional<int64_t>(j, "kindergartening"));
+        x.set_lateritic(get_stack_optional<int64_t>(j, "lateritic"));
+        x.set_mespil(get_stack_optional<int64_t>(j, "mespil"));
+        x.set_misconfiguration(get_stack_optional<int64_t>(j, "misconfiguration"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_planometry(get_stack_optional<int64_t>(j, "planometry"));
+        x.set_quiina(get_stack_optional<int64_t>(j, "Quiina"));
+        x.set_robert(get_stack_optional<int64_t>(j, "Robert"));
+        x.set_rot(get_stack_optional<int64_t>(j, "rot"));
+        x.set_subcinctorium(get_stack_optional<int64_t>(j, "subcinctorium"));
+        x.set_tussocker(get_stack_optional<int64_t>(j, "tussocker"));
+        x.set_ultraproud(get_stack_optional<int64_t>(j, "ultraproud"));
+        x.set_unsuggestedness(get_stack_optional<int64_t>(j, "unsuggestedness"));
+    }
+
+    inline void to_json(json & j, UnimpeachablyClass const & x) {
+        j = json::object();
+        j["acerin"] = x.get_acerin();
+        j["Bobadil"] = x.get_bobadil();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chlorophylligenous"] = x.get_chlorophylligenous();
+        j["conversational"] = x.get_conversational();
+        j["demiowl"] = x.get_demiowl();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ectorhinal"] = x.get_ectorhinal();
+        j["gamblesomeness"] = x.get_gamblesomeness();
+        j["homocerc"] = x.get_homocerc();
+        j["irrorate"] = x.get_irrorate();
+        j["kindergartening"] = x.get_kindergartening();
+        j["lateritic"] = x.get_lateritic();
+        j["mespil"] = x.get_mespil();
+        j["misconfiguration"] = x.get_misconfiguration();
+        j["nonbookish"] = x.get_nonbookish();
+        j["planometry"] = x.get_planometry();
+        j["Quiina"] = x.get_quiina();
+        j["Robert"] = x.get_robert();
+        j["rot"] = x.get_rot();
+        j["subcinctorium"] = x.get_subcinctorium();
+        j["tussocker"] = x.get_tussocker();
+        j["ultraproud"] = x.get_ultraproud();
+        j["unsuggestedness"] = x.get_unsuggestedness();
+    }
+
+    inline void from_json(json const & j, UnstressedClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alain(get_untyped(j, "Alain"));
+        x.set_amphirhina(get_untyped(j, "Amphirhina"));
+        x.set_antimachinery(get_untyped(j, "antimachinery"));
+        x.set_coldish(get_untyped(j, "coldish"));
+        x.set_crantara(get_untyped(j, "crantara"));
+        x.set_distinguishing(get_untyped(j, "distinguishing"));
+        x.set_elytroposis(get_untyped(j, "elytroposis"));
+        x.set_gentianwort(get_untyped(j, "gentianwort"));
+        x.set_heliosis(get_untyped(j, "heliosis"));
+        x.set_instrumental(get_untyped(j, "instrumental"));
+        x.set_introinflection(get_untyped(j, "introinflection"));
+        x.set_kala(get_untyped(j, "kala"));
+        x.set_lincolnian(get_untyped(j, "Lincolnian"));
+        x.set_metad(get_untyped(j, "metad"));
+        x.set_sarcophilus(get_untyped(j, "Sarcophilus"));
+        x.set_swingingly(get_untyped(j, "swingingly"));
+        x.set_unconformity(get_untyped(j, "unconformity"));
+        x.set_undecreed(get_untyped(j, "undecreed"));
+        x.set_venerable(get_untyped(j, "venerable"));
+        x.set_vowellessness(get_untyped(j, "vowellessness"));
+    }
+
+    inline void to_json(json & j, UnstressedClass const & x) {
+        j = json::object();
+        j["Alain"] = x.get_alain();
+        j["Amphirhina"] = x.get_amphirhina();
+        j["antimachinery"] = x.get_antimachinery();
+        j["coldish"] = x.get_coldish();
+        j["crantara"] = x.get_crantara();
+        j["distinguishing"] = x.get_distinguishing();
+        j["elytroposis"] = x.get_elytroposis();
+        j["gentianwort"] = x.get_gentianwort();
+        j["heliosis"] = x.get_heliosis();
+        j["instrumental"] = x.get_instrumental();
+        j["introinflection"] = x.get_introinflection();
+        j["kala"] = x.get_kala();
+        j["Lincolnian"] = x.get_lincolnian();
+        j["metad"] = x.get_metad();
+        j["Sarcophilus"] = x.get_sarcophilus();
+        j["swingingly"] = x.get_swingingly();
+        j["unconformity"] = x.get_unconformity();
+        j["undecreed"] = x.get_undecreed();
+        j["venerable"] = x.get_venerable();
+        j["vowellessness"] = x.get_vowellessness();
+    }
+
+    inline void from_json(json const & j, WrothyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_aeschynanthus(get_untyped(j, "Aeschynanthus"));
+        x.set_aquiferous(get_untyped(j, "aquiferous"));
+        x.set_cheapener(get_untyped(j, "cheapener"));
+        x.set_enumeration(get_untyped(j, "enumeration"));
+        x.set_ephesine(get_untyped(j, "Ephesine"));
+        x.set_escadrille(get_untyped(j, "escadrille"));
+        x.set_estrous(get_untyped(j, "estrous"));
+        x.set_interestedly(get_untyped(j, "interestedly"));
+        x.set_katakinetomer(get_untyped(j, "katakinetomer"));
+        x.set_mortification(get_untyped(j, "mortification"));
+        x.set_morula(get_untyped(j, "morula"));
+        x.set_orthosymmetrical(get_untyped(j, "orthosymmetrical"));
+        x.set_overbark(get_untyped(j, "overbark"));
+        x.set_politist(get_untyped(j, "politist"));
+        x.set_qualified(get_untyped(j, "qualified"));
+        x.set_sphenomalar(get_untyped(j, "sphenomalar"));
+        x.set_throatful(get_untyped(j, "throatful"));
+        x.set_transhumance(get_untyped(j, "transhumance"));
+        x.set_triandrian(get_untyped(j, "triandrian"));
+        x.set_unbooked(get_untyped(j, "unbooked"));
+    }
+
+    inline void to_json(json & j, WrothyClass const & x) {
+        j = json::object();
+        j["Aeschynanthus"] = x.get_aeschynanthus();
+        j["aquiferous"] = x.get_aquiferous();
+        j["cheapener"] = x.get_cheapener();
+        j["enumeration"] = x.get_enumeration();
+        j["Ephesine"] = x.get_ephesine();
+        j["escadrille"] = x.get_escadrille();
+        j["estrous"] = x.get_estrous();
+        j["interestedly"] = x.get_interestedly();
+        j["katakinetomer"] = x.get_katakinetomer();
+        j["mortification"] = x.get_mortification();
+        j["morula"] = x.get_morula();
+        j["orthosymmetrical"] = x.get_orthosymmetrical();
+        j["overbark"] = x.get_overbark();
+        j["politist"] = x.get_politist();
+        j["qualified"] = x.get_qualified();
+        j["sphenomalar"] = x.get_sphenomalar();
+        j["throatful"] = x.get_throatful();
+        j["transhumance"] = x.get_transhumance();
+        j["triandrian"] = x.get_triandrian();
+        j["unbooked"] = x.get_unbooked();
+    }
+
+    inline void from_json(json const & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_protrusive(j.at("protrusive").get<std::vector<Protrusive>>());
+        x.set_pulpitism(j.at("pulpitism").get<std::vector<PulpitismElement>>());
+        x.set_pyodermia(j.at("pyodermia").get<std::vector<PyodermiaElement>>());
+        x.set_quebrachine(j.at("quebrachine").get<std::vector<QuebrachineElement>>());
+        x.set_querier(j.at("querier").get<std::vector<Querier>>());
+        x.set_rebarbative(j.at("rebarbative").get<std::vector<Rebarbative>>());
+        x.set_reimagine(j.at("reimagine").get<std::vector<Reimagine>>());
+        x.set_ressaut(j.at("ressaut").get<Ressaut>());
+        x.set_retrocervical(j.at("retrocervical").get<std::vector<Retrocervical>>());
+        x.set_revert(j.at("revert").get<std::vector<Revert>>());
+        x.set_rewrite(j.at("rewrite").get<std::vector<RewriteElement>>());
+        x.set_saccoderm(j.at("saccoderm").get<std::vector<Saccoderm>>());
+        x.set_santir(j.at("santir").get<std::vector<SantirElement>>());
+        x.set_saprophilous(j.at("saprophilous").get<std::vector<Saprophilous>>());
+        x.set_saxten(j.at("saxten").get<std::vector<SaxtenElement>>());
+        x.set_scatty(j.at("scatty").get<std::vector<std::optional<Scatty>>>());
+        x.set_scoffer(j.at("scoffer").get<std::vector<Scoffer>>());
+        x.set_scrampum(j.at("scrampum").get<std::vector<Scrampum>>());
+        x.set_semantic(j.at("semantic").get<double>());
+        x.set_serpentinic(j.at("serpentinic").get<std::vector<Serpentinic>>());
+        x.set_shadowable(j.at("shadowable").get<std::vector<Shadowable>>());
+        x.set_sistering(j.at("sistering").get<std::vector<SisteringElement>>());
+        x.set_staghunting(j.at("staghunting").get<std::vector<Staghunting>>());
+        x.set_stagmometer(j.at("stagmometer").get<std::vector<Stagmometer>>());
+        x.set_stimulability(j.at("stimulability").get<std::vector<Stimulability>>());
+        x.set_strangleable(j.at("strangleable").get<std::vector<Strangleable>>());
+        x.set_strenuosity(j.at("strenuosity").get<std::vector<StrenuosityElement>>());
+        x.set_tabaxir(j.at("tabaxir").get<std::vector<Tabaxir>>());
+        x.set_talpiform(j.at("talpiform").get<std::vector<Talpiform>>());
+        x.set_thwack(j.at("thwack").get<std::vector<Thwack>>());
+        x.set_to(j.at("to").get<std::vector<std::optional<double>>>());
+        x.set_tortricine(j.at("tortricine").get<std::vector<Tortricine>>());
+        x.set_truantcy(j.at("truantcy").get<std::vector<TruantcyElement>>());
+        x.set_turgesce(j.at("turgesce").get<std::vector<std::string>>());
+        x.set_unbeginning(j.at("unbeginning").get<std::vector<Unbeginning>>());
+        x.set_underdunged(j.at("underdunged").get<std::vector<double>>());
+        x.set_undesirability(j.at("undesirability").get<std::vector<Undesirability>>());
+        x.set_unerasing(j.at("unerasing").get<std::vector<Unerasing>>());
+        x.set_unguentarium(j.at("unguentarium").get<std::vector<Unguentarium>>());
+        x.set_unimpeachably(j.at("unimpeachably").get<std::vector<UnimpeachablyElement>>());
+        x.set_unmortgaged(j.at("unmortgaged").get<std::vector<Unmortgaged>>());
+        x.set_unobstructed(j.at("unobstructed").get<std::vector<Unobstructed>>());
+        x.set_unreceptivity(j.at("unreceptivity").get<std::vector<Unreceptivity>>());
+        x.set_unsatisfactoriness(j.at("unsatisfactoriness").get<std::vector<Unsatisfactoriness>>());
+        x.set_unsecurity(j.at("unsecurity").get<std::vector<int64_t>>());
+        x.set_unstressed(j.at("unstressed").get<std::vector<UnstressedElement>>());
+        x.set_untasked(j.at("untasked").get<std::vector<Untasked>>());
+        x.set_unvarying(j.at("unvarying").get<std::vector<Unvarying>>());
+        x.set_vehemently(j.at("vehemently").get<std::vector<Vehemently>>());
+        x.set_warriorship(j.at("warriorship").get<std::map<std::string, bool>>());
+        x.set_whitepot(j.at("whitepot").get<std::vector<Whitepot>>());
+        x.set_wrothy(j.at("wrothy").get<std::vector<WrothyElement>>());
+    }
+
+    inline void to_json(json & j, TopLevel const & x) {
+        j = json::object();
+        j["protrusive"] = x.get_protrusive();
+        j["pulpitism"] = x.get_pulpitism();
+        j["pyodermia"] = x.get_pyodermia();
+        j["quebrachine"] = x.get_quebrachine();
+        j["querier"] = x.get_querier();
+        j["rebarbative"] = x.get_rebarbative();
+        j["reimagine"] = x.get_reimagine();
+        j["ressaut"] = x.get_ressaut();
+        j["retrocervical"] = x.get_retrocervical();
+        j["revert"] = x.get_revert();
+        j["rewrite"] = x.get_rewrite();
+        j["saccoderm"] = x.get_saccoderm();
+        j["santir"] = x.get_santir();
+        j["saprophilous"] = x.get_saprophilous();
+        j["saxten"] = x.get_saxten();
+        j["scatty"] = x.get_scatty();
+        j["scoffer"] = x.get_scoffer();
+        j["scrampum"] = x.get_scrampum();
+        j["semantic"] = x.get_semantic();
+        j["serpentinic"] = x.get_serpentinic();
+        j["shadowable"] = x.get_shadowable();
+        j["sistering"] = x.get_sistering();
+        j["staghunting"] = x.get_staghunting();
+        j["stagmometer"] = x.get_stagmometer();
+        j["stimulability"] = x.get_stimulability();
+        j["strangleable"] = x.get_strangleable();
+        j["strenuosity"] = x.get_strenuosity();
+        j["tabaxir"] = x.get_tabaxir();
+        j["talpiform"] = x.get_talpiform();
+        j["thwack"] = x.get_thwack();
+        j["to"] = x.get_to();
+        j["tortricine"] = x.get_tortricine();
+        j["truantcy"] = x.get_truantcy();
+        j["turgesce"] = x.get_turgesce();
+        j["unbeginning"] = x.get_unbeginning();
+        j["underdunged"] = x.get_underdunged();
+        j["undesirability"] = x.get_undesirability();
+        j["unerasing"] = x.get_unerasing();
+        j["unguentarium"] = x.get_unguentarium();
+        j["unimpeachably"] = x.get_unimpeachably();
+        j["unmortgaged"] = x.get_unmortgaged();
+        j["unobstructed"] = x.get_unobstructed();
+        j["unreceptivity"] = x.get_unreceptivity();
+        j["unsatisfactoriness"] = x.get_unsatisfactoriness();
+        j["unsecurity"] = x.get_unsecurity();
+        j["unstressed"] = x.get_unstressed();
+        j["untasked"] = x.get_untasked();
+        j["unvarying"] = x.get_unvarying();
+        j["vehemently"] = x.get_vehemently();
+        j["warriorship"] = x.get_warriorship();
+        j["whitepot"] = x.get_whitepot();
+        j["wrothy"] = x.get_wrothy();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>>::from_json(json const & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::PulpitismClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>>::to_json(json & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::PulpitismClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>>::from_json(json const & j, std::variant<quicktype::PyodermiaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::PyodermiaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>>::to_json(json & j, std::variant<quicktype::PyodermiaClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PyodermiaClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass>>::from_json(json const & j, std::variant<bool, quicktype::QuebrachineClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass>>::to_json(json & j, std::variant<bool, quicktype::QuebrachineClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<bool, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, double>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, double>>::to_json(json & j, std::variant<std::vector<int64_t>, bool, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::from_json(json const & j, std::variant<bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::to_json(json & j, std::variant<bool, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::RewriteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>>::to_json(json & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::RewriteClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SantirClass, double>>::from_json(json const & j, std::variant<quicktype::SantirClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::SantirClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SantirClass, double>>::to_json(json & j, std::variant<quicktype::SantirClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SantirClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SaxtenClass, std::string>>::from_json(json const & j, std::variant<quicktype::SaxtenClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::SaxtenClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SaxtenClass, std::string>>::to_json(json & j, std::variant<quicktype::SaxtenClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SaxtenClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::to_json(json & j, std::variant<std::vector<int64_t>, bool> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(json const & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, std::variant<std::vector<int64_t>, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, bool> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::SisteringClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>>::to_json(json & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::SisteringClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::from_json(json const & j, std::variant<std::vector<json>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::to_json(json & j, std::variant<std::vector<json>, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::StrenuosityClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>>::to_json(json & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::StrenuosityClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(json const & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, std::variant<bool, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, double>>::from_json(json const & j, std::variant<quicktype::QuebrachineClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, double>>::to_json(json & j, std::variant<quicktype::QuebrachineClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>>::from_json(json const & j, std::variant<bool, quicktype::QuebrachineClass, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>>::to_json(json & j, std::variant<bool, quicktype::QuebrachineClass, double> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>>::from_json(json const & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>>::to_json(json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::TruantcyClass>>::from_json(json const & j, std::variant<bool, quicktype::TruantcyClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::TruantcyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::TruantcyClass>>::to_json(json & j, std::variant<bool, quicktype::TruantcyClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::TruantcyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>>::from_json(json const & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>>::to_json(json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::from_json(json const & j, std::variant<std::vector<json>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::to_json(json & j, std::variant<std::vector<json>, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>>::from_json(json const & j, std::variant<bool, quicktype::UnimpeachablyClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnimpeachablyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>>::to_json(json & j, std::variant<bool, quicktype::UnimpeachablyClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::UnimpeachablyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<double, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>>::from_json(json const & j, std::variant<quicktype::QuebrachineClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>>::to_json(json & j, std::variant<quicktype::QuebrachineClass, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::string>>::from_json(json const & j, std::variant<std::vector<json>, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::string>>::to_json(json & j, std::variant<std::vector<json>, int64_t, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>>::from_json(json const & j, std::variant<std::vector<int64_t>, bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>>::to_json(json & j, std::variant<std::vector<int64_t>, bool, int64_t> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>>::from_json(json const & j, std::variant<bool, quicktype::UnstressedClass, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnstressedClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>>::to_json(json & j, std::variant<bool, quicktype::UnstressedClass, std::string> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::UnstressedClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>>::from_json(json const & j, std::variant<bool, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>>::to_json(json & j, std::variant<bool, double, std::map<std::string, int64_t>> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::from_json(json const & j, std::variant<std::vector<json>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::to_json(json & j, std::variant<std::vector<json>, bool> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>>::from_json(json const & j, std::variant<std::vector<json>, quicktype::WrothyClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::WrothyClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>>::to_json(json & j, std::variant<std::vector<json>, quicktype::WrothyClass> const & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::WrothyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/cplusplus/test/inputs/json/priority/combinations4.json/default/quicktype.hpp b/head/cplusplus/test/inputs/json/priority/combinations4.json/default/quicktype.hpp
new file mode 100644
index 0000000..31df459
--- /dev/null
+++ b/head/cplusplus/test/inputs/json/priority/combinations4.json/default/quicktype.hpp
@@ -0,0 +1,4365 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    using Protrusive = std::variant<std::vector<std::optional<int64_t>>, double>;
+
+    class PulpitismClass {
+        public:
+        PulpitismClass() = default;
+        virtual ~PulpitismClass() = default;
+
+        private:
+        nlohmann::json abnet;
+        nlohmann::json buckhorn;
+        nlohmann::json calciform;
+        nlohmann::json chelophore;
+        nlohmann::json cogitation;
+        nlohmann::json decreeable;
+        nlohmann::json despicable;
+        nlohmann::json isodiazo;
+        nlohmann::json jadedly;
+        nlohmann::json leptochlorite;
+        nlohmann::json nursling;
+        nlohmann::json palamedean;
+        nlohmann::json photoheliograph;
+        nlohmann::json pipewood;
+        nlohmann::json roberd;
+        nlohmann::json statable;
+        nlohmann::json superassume;
+        nlohmann::json syllabe;
+        nlohmann::json toughhead;
+        nlohmann::json underburn;
+
+        public:
+        const nlohmann::json & get_abnet() const { return abnet; }
+        nlohmann::json & get_mutable_abnet() { return abnet; }
+        void set_abnet(const nlohmann::json & value) { this->abnet = value; }
+
+        const nlohmann::json & get_buckhorn() const { return buckhorn; }
+        nlohmann::json & get_mutable_buckhorn() { return buckhorn; }
+        void set_buckhorn(const nlohmann::json & value) { this->buckhorn = value; }
+
+        const nlohmann::json & get_calciform() const { return calciform; }
+        nlohmann::json & get_mutable_calciform() { return calciform; }
+        void set_calciform(const nlohmann::json & value) { this->calciform = value; }
+
+        const nlohmann::json & get_chelophore() const { return chelophore; }
+        nlohmann::json & get_mutable_chelophore() { return chelophore; }
+        void set_chelophore(const nlohmann::json & value) { this->chelophore = value; }
+
+        const nlohmann::json & get_cogitation() const { return cogitation; }
+        nlohmann::json & get_mutable_cogitation() { return cogitation; }
+        void set_cogitation(const nlohmann::json & value) { this->cogitation = value; }
+
+        const nlohmann::json & get_decreeable() const { return decreeable; }
+        nlohmann::json & get_mutable_decreeable() { return decreeable; }
+        void set_decreeable(const nlohmann::json & value) { this->decreeable = value; }
+
+        const nlohmann::json & get_despicable() const { return despicable; }
+        nlohmann::json & get_mutable_despicable() { return despicable; }
+        void set_despicable(const nlohmann::json & value) { this->despicable = value; }
+
+        const nlohmann::json & get_isodiazo() const { return isodiazo; }
+        nlohmann::json & get_mutable_isodiazo() { return isodiazo; }
+        void set_isodiazo(const nlohmann::json & value) { this->isodiazo = value; }
+
+        const nlohmann::json & get_jadedly() const { return jadedly; }
+        nlohmann::json & get_mutable_jadedly() { return jadedly; }
+        void set_jadedly(const nlohmann::json & value) { this->jadedly = value; }
+
+        const nlohmann::json & get_leptochlorite() const { return leptochlorite; }
+        nlohmann::json & get_mutable_leptochlorite() { return leptochlorite; }
+        void set_leptochlorite(const nlohmann::json & value) { this->leptochlorite = value; }
+
+        const nlohmann::json & get_nursling() const { return nursling; }
+        nlohmann::json & get_mutable_nursling() { return nursling; }
+        void set_nursling(const nlohmann::json & value) { this->nursling = value; }
+
+        const nlohmann::json & get_palamedean() const { return palamedean; }
+        nlohmann::json & get_mutable_palamedean() { return palamedean; }
+        void set_palamedean(const nlohmann::json & value) { this->palamedean = value; }
+
+        const nlohmann::json & get_photoheliograph() const { return photoheliograph; }
+        nlohmann::json & get_mutable_photoheliograph() { return photoheliograph; }
+        void set_photoheliograph(const nlohmann::json & value) { this->photoheliograph = value; }
+
+        const nlohmann::json & get_pipewood() const { return pipewood; }
+        nlohmann::json & get_mutable_pipewood() { return pipewood; }
+        void set_pipewood(const nlohmann::json & value) { this->pipewood = value; }
+
+        const nlohmann::json & get_roberd() const { return roberd; }
+        nlohmann::json & get_mutable_roberd() { return roberd; }
+        void set_roberd(const nlohmann::json & value) { this->roberd = value; }
+
+        const nlohmann::json & get_statable() const { return statable; }
+        nlohmann::json & get_mutable_statable() { return statable; }
+        void set_statable(const nlohmann::json & value) { this->statable = value; }
+
+        const nlohmann::json & get_superassume() const { return superassume; }
+        nlohmann::json & get_mutable_superassume() { return superassume; }
+        void set_superassume(const nlohmann::json & value) { this->superassume = value; }
+
+        const nlohmann::json & get_syllabe() const { return syllabe; }
+        nlohmann::json & get_mutable_syllabe() { return syllabe; }
+        void set_syllabe(const nlohmann::json & value) { this->syllabe = value; }
+
+        const nlohmann::json & get_toughhead() const { return toughhead; }
+        nlohmann::json & get_mutable_toughhead() { return toughhead; }
+        void set_toughhead(const nlohmann::json & value) { this->toughhead = value; }
+
+        const nlohmann::json & get_underburn() const { return underburn; }
+        nlohmann::json & get_mutable_underburn() { return underburn; }
+        void set_underburn(const nlohmann::json & value) { this->underburn = value; }
+    };
+
+    using PulpitismElement = std::variant<std::vector<int64_t>, PulpitismClass, double>;
+
+    class PyodermiaClass {
+        public:
+        PyodermiaClass() = default;
+        virtual ~PyodermiaClass() = default;
+
+        private:
+        nlohmann::json aphoristically;
+        nlohmann::json apophyllous;
+        nlohmann::json cognize;
+        nlohmann::json dermonosology;
+        nlohmann::json gyppo;
+        nlohmann::json ither;
+        nlohmann::json juglandaceous;
+        nlohmann::json litho;
+        nlohmann::json macropterous;
+        nlohmann::json photographer;
+        nlohmann::json romancing;
+        nlohmann::json rumness;
+        nlohmann::json somniloquist;
+        nlohmann::json stressfully;
+        nlohmann::json tactically;
+        nlohmann::json tracheophony;
+        nlohmann::json unappositely;
+        nlohmann::json unclothedly;
+        nlohmann::json unimplied;
+        nlohmann::json unsyncopated;
+
+        public:
+        const nlohmann::json & get_aphoristically() const { return aphoristically; }
+        nlohmann::json & get_mutable_aphoristically() { return aphoristically; }
+        void set_aphoristically(const nlohmann::json & value) { this->aphoristically = value; }
+
+        const nlohmann::json & get_apophyllous() const { return apophyllous; }
+        nlohmann::json & get_mutable_apophyllous() { return apophyllous; }
+        void set_apophyllous(const nlohmann::json & value) { this->apophyllous = value; }
+
+        const nlohmann::json & get_cognize() const { return cognize; }
+        nlohmann::json & get_mutable_cognize() { return cognize; }
+        void set_cognize(const nlohmann::json & value) { this->cognize = value; }
+
+        const nlohmann::json & get_dermonosology() const { return dermonosology; }
+        nlohmann::json & get_mutable_dermonosology() { return dermonosology; }
+        void set_dermonosology(const nlohmann::json & value) { this->dermonosology = value; }
+
+        const nlohmann::json & get_gyppo() const { return gyppo; }
+        nlohmann::json & get_mutable_gyppo() { return gyppo; }
+        void set_gyppo(const nlohmann::json & value) { this->gyppo = value; }
+
+        const nlohmann::json & get_ither() const { return ither; }
+        nlohmann::json & get_mutable_ither() { return ither; }
+        void set_ither(const nlohmann::json & value) { this->ither = value; }
+
+        const nlohmann::json & get_juglandaceous() const { return juglandaceous; }
+        nlohmann::json & get_mutable_juglandaceous() { return juglandaceous; }
+        void set_juglandaceous(const nlohmann::json & value) { this->juglandaceous = value; }
+
+        const nlohmann::json & get_litho() const { return litho; }
+        nlohmann::json & get_mutable_litho() { return litho; }
+        void set_litho(const nlohmann::json & value) { this->litho = value; }
+
+        const nlohmann::json & get_macropterous() const { return macropterous; }
+        nlohmann::json & get_mutable_macropterous() { return macropterous; }
+        void set_macropterous(const nlohmann::json & value) { this->macropterous = value; }
+
+        const nlohmann::json & get_photographer() const { return photographer; }
+        nlohmann::json & get_mutable_photographer() { return photographer; }
+        void set_photographer(const nlohmann::json & value) { this->photographer = value; }
+
+        const nlohmann::json & get_romancing() const { return romancing; }
+        nlohmann::json & get_mutable_romancing() { return romancing; }
+        void set_romancing(const nlohmann::json & value) { this->romancing = value; }
+
+        const nlohmann::json & get_rumness() const { return rumness; }
+        nlohmann::json & get_mutable_rumness() { return rumness; }
+        void set_rumness(const nlohmann::json & value) { this->rumness = value; }
+
+        const nlohmann::json & get_somniloquist() const { return somniloquist; }
+        nlohmann::json & get_mutable_somniloquist() { return somniloquist; }
+        void set_somniloquist(const nlohmann::json & value) { this->somniloquist = value; }
+
+        const nlohmann::json & get_stressfully() const { return stressfully; }
+        nlohmann::json & get_mutable_stressfully() { return stressfully; }
+        void set_stressfully(const nlohmann::json & value) { this->stressfully = value; }
+
+        const nlohmann::json & get_tactically() const { return tactically; }
+        nlohmann::json & get_mutable_tactically() { return tactically; }
+        void set_tactically(const nlohmann::json & value) { this->tactically = value; }
+
+        const nlohmann::json & get_tracheophony() const { return tracheophony; }
+        nlohmann::json & get_mutable_tracheophony() { return tracheophony; }
+        void set_tracheophony(const nlohmann::json & value) { this->tracheophony = value; }
+
+        const nlohmann::json & get_unappositely() const { return unappositely; }
+        nlohmann::json & get_mutable_unappositely() { return unappositely; }
+        void set_unappositely(const nlohmann::json & value) { this->unappositely = value; }
+
+        const nlohmann::json & get_unclothedly() const { return unclothedly; }
+        nlohmann::json & get_mutable_unclothedly() { return unclothedly; }
+        void set_unclothedly(const nlohmann::json & value) { this->unclothedly = value; }
+
+        const nlohmann::json & get_unimplied() const { return unimplied; }
+        nlohmann::json & get_mutable_unimplied() { return unimplied; }
+        void set_unimplied(const nlohmann::json & value) { this->unimplied = value; }
+
+        const nlohmann::json & get_unsyncopated() const { return unsyncopated; }
+        nlohmann::json & get_mutable_unsyncopated() { return unsyncopated; }
+        void set_unsyncopated(const nlohmann::json & value) { this->unsyncopated = value; }
+    };
+
+    using PyodermiaElement = std::variant<PyodermiaClass, int64_t>;
+
+    class QuebrachineClass {
+        public:
+        QuebrachineClass() = default;
+        virtual ~QuebrachineClass() = default;
+
+        private:
+        double catharticalness;
+        int64_t chirotherium;
+        std::string disdiapason;
+        bool homocerc;
+        nlohmann::json nonbookish;
+
+        public:
+        const double & get_catharticalness() const { return catharticalness; }
+        double & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const double & value) { this->catharticalness = value; }
+
+        const int64_t & get_chirotherium() const { return chirotherium; }
+        int64_t & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const int64_t & value) { this->chirotherium = value; }
+
+        const std::string & get_disdiapason() const { return disdiapason; }
+        std::string & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::string & value) { this->disdiapason = value; }
+
+        const bool & get_homocerc() const { return homocerc; }
+        bool & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const bool & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+    };
+
+    using QuebrachineElement = std::optional<std::variant<bool, QuebrachineClass>>;
+
+    using Querier = std::variant<bool, std::map<std::string, int64_t>>;
+
+    using Rebarbative = std::variant<std::vector<int64_t>, bool, double>;
+
+    class Reimagine {
+        public:
+        Reimagine() = default;
+        virtual ~Reimagine() = default;
+
+        private:
+        nlohmann::json adducible;
+        nlohmann::json anabolin;
+        nlohmann::json brainy;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json chrysamine;
+        std::optional<std::string> disdiapason;
+        nlohmann::json fluxweed;
+        nlohmann::json glaucine;
+        nlohmann::json grobianism;
+        nlohmann::json hermo;
+        nlohmann::json hieroglyphist;
+        std::optional<bool> homocerc;
+        nlohmann::json icteroid;
+        nlohmann::json immortal;
+        nlohmann::json impetulant;
+        nlohmann::json irrigate;
+        nlohmann::json myxedema;
+        nlohmann::json nonbookish;
+        nlohmann::json onyx;
+        nlohmann::json repasser;
+        nlohmann::json septomarginal;
+        nlohmann::json subdie;
+        nlohmann::json tibiometatarsal;
+        nlohmann::json waltzlike;
+
+        public:
+        const nlohmann::json & get_adducible() const { return adducible; }
+        nlohmann::json & get_mutable_adducible() { return adducible; }
+        void set_adducible(const nlohmann::json & value) { this->adducible = value; }
+
+        const nlohmann::json & get_anabolin() const { return anabolin; }
+        nlohmann::json & get_mutable_anabolin() { return anabolin; }
+        void set_anabolin(const nlohmann::json & value) { this->anabolin = value; }
+
+        const nlohmann::json & get_brainy() const { return brainy; }
+        nlohmann::json & get_mutable_brainy() { return brainy; }
+        void set_brainy(const nlohmann::json & value) { this->brainy = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const nlohmann::json & get_chrysamine() const { return chrysamine; }
+        nlohmann::json & get_mutable_chrysamine() { return chrysamine; }
+        void set_chrysamine(const nlohmann::json & value) { this->chrysamine = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_fluxweed() const { return fluxweed; }
+        nlohmann::json & get_mutable_fluxweed() { return fluxweed; }
+        void set_fluxweed(const nlohmann::json & value) { this->fluxweed = value; }
+
+        const nlohmann::json & get_glaucine() const { return glaucine; }
+        nlohmann::json & get_mutable_glaucine() { return glaucine; }
+        void set_glaucine(const nlohmann::json & value) { this->glaucine = value; }
+
+        const nlohmann::json & get_grobianism() const { return grobianism; }
+        nlohmann::json & get_mutable_grobianism() { return grobianism; }
+        void set_grobianism(const nlohmann::json & value) { this->grobianism = value; }
+
+        const nlohmann::json & get_hermo() const { return hermo; }
+        nlohmann::json & get_mutable_hermo() { return hermo; }
+        void set_hermo(const nlohmann::json & value) { this->hermo = value; }
+
+        const nlohmann::json & get_hieroglyphist() const { return hieroglyphist; }
+        nlohmann::json & get_mutable_hieroglyphist() { return hieroglyphist; }
+        void set_hieroglyphist(const nlohmann::json & value) { this->hieroglyphist = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_icteroid() const { return icteroid; }
+        nlohmann::json & get_mutable_icteroid() { return icteroid; }
+        void set_icteroid(const nlohmann::json & value) { this->icteroid = value; }
+
+        const nlohmann::json & get_immortal() const { return immortal; }
+        nlohmann::json & get_mutable_immortal() { return immortal; }
+        void set_immortal(const nlohmann::json & value) { this->immortal = value; }
+
+        const nlohmann::json & get_impetulant() const { return impetulant; }
+        nlohmann::json & get_mutable_impetulant() { return impetulant; }
+        void set_impetulant(const nlohmann::json & value) { this->impetulant = value; }
+
+        const nlohmann::json & get_irrigate() const { return irrigate; }
+        nlohmann::json & get_mutable_irrigate() { return irrigate; }
+        void set_irrigate(const nlohmann::json & value) { this->irrigate = value; }
+
+        const nlohmann::json & get_myxedema() const { return myxedema; }
+        nlohmann::json & get_mutable_myxedema() { return myxedema; }
+        void set_myxedema(const nlohmann::json & value) { this->myxedema = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_onyx() const { return onyx; }
+        nlohmann::json & get_mutable_onyx() { return onyx; }
+        void set_onyx(const nlohmann::json & value) { this->onyx = value; }
+
+        const nlohmann::json & get_repasser() const { return repasser; }
+        nlohmann::json & get_mutable_repasser() { return repasser; }
+        void set_repasser(const nlohmann::json & value) { this->repasser = value; }
+
+        const nlohmann::json & get_septomarginal() const { return septomarginal; }
+        nlohmann::json & get_mutable_septomarginal() { return septomarginal; }
+        void set_septomarginal(const nlohmann::json & value) { this->septomarginal = value; }
+
+        const nlohmann::json & get_subdie() const { return subdie; }
+        nlohmann::json & get_mutable_subdie() { return subdie; }
+        void set_subdie(const nlohmann::json & value) { this->subdie = value; }
+
+        const nlohmann::json & get_tibiometatarsal() const { return tibiometatarsal; }
+        nlohmann::json & get_mutable_tibiometatarsal() { return tibiometatarsal; }
+        void set_tibiometatarsal(const nlohmann::json & value) { this->tibiometatarsal = value; }
+
+        const nlohmann::json & get_waltzlike() const { return waltzlike; }
+        nlohmann::json & get_mutable_waltzlike() { return waltzlike; }
+        void set_waltzlike(const nlohmann::json & value) { this->waltzlike = value; }
+    };
+
+    class Ressaut {
+        public:
+        Ressaut() = default;
+        virtual ~Ressaut() = default;
+
+        private:
+        std::string apperceptive;
+        std::string cuttoo;
+        std::string douser;
+        std::string drinkproof;
+        std::string forementioned;
+        std::string freesia;
+        std::string genevieve;
+        std::string hyperdiabolical;
+        std::string hypocone;
+        std::string irreverentially;
+        std::string jumart;
+        std::string mimosaceae;
+        std::string mollicrush;
+        std::string nedder;
+        std::string retinasphalt;
+        std::string sough;
+        std::string steading;
+        std::string theopaschitism;
+        std::string undurableness;
+        std::string unmingleable;
+
+        public:
+        const std::string & get_apperceptive() const { return apperceptive; }
+        std::string & get_mutable_apperceptive() { return apperceptive; }
+        void set_apperceptive(const std::string & value) { this->apperceptive = value; }
+
+        const std::string & get_cuttoo() const { return cuttoo; }
+        std::string & get_mutable_cuttoo() { return cuttoo; }
+        void set_cuttoo(const std::string & value) { this->cuttoo = value; }
+
+        const std::string & get_douser() const { return douser; }
+        std::string & get_mutable_douser() { return douser; }
+        void set_douser(const std::string & value) { this->douser = value; }
+
+        const std::string & get_drinkproof() const { return drinkproof; }
+        std::string & get_mutable_drinkproof() { return drinkproof; }
+        void set_drinkproof(const std::string & value) { this->drinkproof = value; }
+
+        const std::string & get_forementioned() const { return forementioned; }
+        std::string & get_mutable_forementioned() { return forementioned; }
+        void set_forementioned(const std::string & value) { this->forementioned = value; }
+
+        const std::string & get_freesia() const { return freesia; }
+        std::string & get_mutable_freesia() { return freesia; }
+        void set_freesia(const std::string & value) { this->freesia = value; }
+
+        const std::string & get_genevieve() const { return genevieve; }
+        std::string & get_mutable_genevieve() { return genevieve; }
+        void set_genevieve(const std::string & value) { this->genevieve = value; }
+
+        const std::string & get_hyperdiabolical() const { return hyperdiabolical; }
+        std::string & get_mutable_hyperdiabolical() { return hyperdiabolical; }
+        void set_hyperdiabolical(const std::string & value) { this->hyperdiabolical = value; }
+
+        const std::string & get_hypocone() const { return hypocone; }
+        std::string & get_mutable_hypocone() { return hypocone; }
+        void set_hypocone(const std::string & value) { this->hypocone = value; }
+
+        const std::string & get_irreverentially() const { return irreverentially; }
+        std::string & get_mutable_irreverentially() { return irreverentially; }
+        void set_irreverentially(const std::string & value) { this->irreverentially = value; }
+
+        const std::string & get_jumart() const { return jumart; }
+        std::string & get_mutable_jumart() { return jumart; }
+        void set_jumart(const std::string & value) { this->jumart = value; }
+
+        const std::string & get_mimosaceae() const { return mimosaceae; }
+        std::string & get_mutable_mimosaceae() { return mimosaceae; }
+        void set_mimosaceae(const std::string & value) { this->mimosaceae = value; }
+
+        const std::string & get_mollicrush() const { return mollicrush; }
+        std::string & get_mutable_mollicrush() { return mollicrush; }
+        void set_mollicrush(const std::string & value) { this->mollicrush = value; }
+
+        const std::string & get_nedder() const { return nedder; }
+        std::string & get_mutable_nedder() { return nedder; }
+        void set_nedder(const std::string & value) { this->nedder = value; }
+
+        const std::string & get_retinasphalt() const { return retinasphalt; }
+        std::string & get_mutable_retinasphalt() { return retinasphalt; }
+        void set_retinasphalt(const std::string & value) { this->retinasphalt = value; }
+
+        const std::string & get_sough() const { return sough; }
+        std::string & get_mutable_sough() { return sough; }
+        void set_sough(const std::string & value) { this->sough = value; }
+
+        const std::string & get_steading() const { return steading; }
+        std::string & get_mutable_steading() { return steading; }
+        void set_steading(const std::string & value) { this->steading = value; }
+
+        const std::string & get_theopaschitism() const { return theopaschitism; }
+        std::string & get_mutable_theopaschitism() { return theopaschitism; }
+        void set_theopaschitism(const std::string & value) { this->theopaschitism = value; }
+
+        const std::string & get_undurableness() const { return undurableness; }
+        std::string & get_mutable_undurableness() { return undurableness; }
+        void set_undurableness(const std::string & value) { this->undurableness = value; }
+
+        const std::string & get_unmingleable() const { return unmingleable; }
+        std::string & get_mutable_unmingleable() { return unmingleable; }
+        void set_unmingleable(const std::string & value) { this->unmingleable = value; }
+    };
+
+    using Retrocervical = std::variant<std::vector<std::optional<int64_t>>, int64_t>;
+
+    using Revert = std::variant<bool, std::string>;
+
+    class RewriteClass {
+        public:
+        RewriteClass() = default;
+        virtual ~RewriteClass() = default;
+
+        private:
+        nlohmann::json accountancy;
+        nlohmann::json cacotrophic;
+        nlohmann::json contest;
+        nlohmann::json couthily;
+        nlohmann::json falculate;
+        nlohmann::json foreseize;
+        nlohmann::json hyades;
+        nlohmann::json lemnad;
+        nlohmann::json monotheistically;
+        nlohmann::json nonflying;
+        nlohmann::json ptenoglossa;
+        nlohmann::json repatch;
+        nlohmann::json rodman;
+        nlohmann::json strung;
+        nlohmann::json titmal;
+        nlohmann::json twalpennyworth;
+        nlohmann::json unblamable;
+        nlohmann::json vertical;
+        nlohmann::json whiggification;
+        nlohmann::json yardman;
+
+        public:
+        const nlohmann::json & get_accountancy() const { return accountancy; }
+        nlohmann::json & get_mutable_accountancy() { return accountancy; }
+        void set_accountancy(const nlohmann::json & value) { this->accountancy = value; }
+
+        const nlohmann::json & get_cacotrophic() const { return cacotrophic; }
+        nlohmann::json & get_mutable_cacotrophic() { return cacotrophic; }
+        void set_cacotrophic(const nlohmann::json & value) { this->cacotrophic = value; }
+
+        const nlohmann::json & get_contest() const { return contest; }
+        nlohmann::json & get_mutable_contest() { return contest; }
+        void set_contest(const nlohmann::json & value) { this->contest = value; }
+
+        const nlohmann::json & get_couthily() const { return couthily; }
+        nlohmann::json & get_mutable_couthily() { return couthily; }
+        void set_couthily(const nlohmann::json & value) { this->couthily = value; }
+
+        const nlohmann::json & get_falculate() const { return falculate; }
+        nlohmann::json & get_mutable_falculate() { return falculate; }
+        void set_falculate(const nlohmann::json & value) { this->falculate = value; }
+
+        const nlohmann::json & get_foreseize() const { return foreseize; }
+        nlohmann::json & get_mutable_foreseize() { return foreseize; }
+        void set_foreseize(const nlohmann::json & value) { this->foreseize = value; }
+
+        const nlohmann::json & get_hyades() const { return hyades; }
+        nlohmann::json & get_mutable_hyades() { return hyades; }
+        void set_hyades(const nlohmann::json & value) { this->hyades = value; }
+
+        const nlohmann::json & get_lemnad() const { return lemnad; }
+        nlohmann::json & get_mutable_lemnad() { return lemnad; }
+        void set_lemnad(const nlohmann::json & value) { this->lemnad = value; }
+
+        const nlohmann::json & get_monotheistically() const { return monotheistically; }
+        nlohmann::json & get_mutable_monotheistically() { return monotheistically; }
+        void set_monotheistically(const nlohmann::json & value) { this->monotheistically = value; }
+
+        const nlohmann::json & get_nonflying() const { return nonflying; }
+        nlohmann::json & get_mutable_nonflying() { return nonflying; }
+        void set_nonflying(const nlohmann::json & value) { this->nonflying = value; }
+
+        const nlohmann::json & get_ptenoglossa() const { return ptenoglossa; }
+        nlohmann::json & get_mutable_ptenoglossa() { return ptenoglossa; }
+        void set_ptenoglossa(const nlohmann::json & value) { this->ptenoglossa = value; }
+
+        const nlohmann::json & get_repatch() const { return repatch; }
+        nlohmann::json & get_mutable_repatch() { return repatch; }
+        void set_repatch(const nlohmann::json & value) { this->repatch = value; }
+
+        const nlohmann::json & get_rodman() const { return rodman; }
+        nlohmann::json & get_mutable_rodman() { return rodman; }
+        void set_rodman(const nlohmann::json & value) { this->rodman = value; }
+
+        const nlohmann::json & get_strung() const { return strung; }
+        nlohmann::json & get_mutable_strung() { return strung; }
+        void set_strung(const nlohmann::json & value) { this->strung = value; }
+
+        const nlohmann::json & get_titmal() const { return titmal; }
+        nlohmann::json & get_mutable_titmal() { return titmal; }
+        void set_titmal(const nlohmann::json & value) { this->titmal = value; }
+
+        const nlohmann::json & get_twalpennyworth() const { return twalpennyworth; }
+        nlohmann::json & get_mutable_twalpennyworth() { return twalpennyworth; }
+        void set_twalpennyworth(const nlohmann::json & value) { this->twalpennyworth = value; }
+
+        const nlohmann::json & get_unblamable() const { return unblamable; }
+        nlohmann::json & get_mutable_unblamable() { return unblamable; }
+        void set_unblamable(const nlohmann::json & value) { this->unblamable = value; }
+
+        const nlohmann::json & get_vertical() const { return vertical; }
+        nlohmann::json & get_mutable_vertical() { return vertical; }
+        void set_vertical(const nlohmann::json & value) { this->vertical = value; }
+
+        const nlohmann::json & get_whiggification() const { return whiggification; }
+        nlohmann::json & get_mutable_whiggification() { return whiggification; }
+        void set_whiggification(const nlohmann::json & value) { this->whiggification = value; }
+
+        const nlohmann::json & get_yardman() const { return yardman; }
+        nlohmann::json & get_mutable_yardman() { return yardman; }
+        void set_yardman(const nlohmann::json & value) { this->yardman = value; }
+    };
+
+    using RewriteElement = std::variant<std::vector<nlohmann::json>, RewriteClass, double>;
+
+    using Saccoderm = std::optional<std::variant<std::vector<int64_t>, std::string>>;
+
+    class SantirClass {
+        public:
+        SantirClass() = default;
+        virtual ~SantirClass() = default;
+
+        private:
+        nlohmann::json admiredly;
+        nlohmann::json demicaponier;
+        nlohmann::json epitympanic;
+        nlohmann::json investitor;
+        nlohmann::json lupiform;
+        nlohmann::json monoflagellate;
+        nlohmann::json paleoethnic;
+        nlohmann::json prediscountable;
+        nlohmann::json rhetoricals;
+        nlohmann::json roomth;
+        nlohmann::json saccharose;
+        nlohmann::json septonasal;
+        nlohmann::json serpenticide;
+        nlohmann::json setarious;
+        nlohmann::json spaework;
+        nlohmann::json stylite;
+        nlohmann::json suessiones;
+        nlohmann::json timelily;
+        nlohmann::json unprofaned;
+        nlohmann::json vorticular;
+
+        public:
+        const nlohmann::json & get_admiredly() const { return admiredly; }
+        nlohmann::json & get_mutable_admiredly() { return admiredly; }
+        void set_admiredly(const nlohmann::json & value) { this->admiredly = value; }
+
+        const nlohmann::json & get_demicaponier() const { return demicaponier; }
+        nlohmann::json & get_mutable_demicaponier() { return demicaponier; }
+        void set_demicaponier(const nlohmann::json & value) { this->demicaponier = value; }
+
+        const nlohmann::json & get_epitympanic() const { return epitympanic; }
+        nlohmann::json & get_mutable_epitympanic() { return epitympanic; }
+        void set_epitympanic(const nlohmann::json & value) { this->epitympanic = value; }
+
+        const nlohmann::json & get_investitor() const { return investitor; }
+        nlohmann::json & get_mutable_investitor() { return investitor; }
+        void set_investitor(const nlohmann::json & value) { this->investitor = value; }
+
+        const nlohmann::json & get_lupiform() const { return lupiform; }
+        nlohmann::json & get_mutable_lupiform() { return lupiform; }
+        void set_lupiform(const nlohmann::json & value) { this->lupiform = value; }
+
+        const nlohmann::json & get_monoflagellate() const { return monoflagellate; }
+        nlohmann::json & get_mutable_monoflagellate() { return monoflagellate; }
+        void set_monoflagellate(const nlohmann::json & value) { this->monoflagellate = value; }
+
+        const nlohmann::json & get_paleoethnic() const { return paleoethnic; }
+        nlohmann::json & get_mutable_paleoethnic() { return paleoethnic; }
+        void set_paleoethnic(const nlohmann::json & value) { this->paleoethnic = value; }
+
+        const nlohmann::json & get_prediscountable() const { return prediscountable; }
+        nlohmann::json & get_mutable_prediscountable() { return prediscountable; }
+        void set_prediscountable(const nlohmann::json & value) { this->prediscountable = value; }
+
+        const nlohmann::json & get_rhetoricals() const { return rhetoricals; }
+        nlohmann::json & get_mutable_rhetoricals() { return rhetoricals; }
+        void set_rhetoricals(const nlohmann::json & value) { this->rhetoricals = value; }
+
+        const nlohmann::json & get_roomth() const { return roomth; }
+        nlohmann::json & get_mutable_roomth() { return roomth; }
+        void set_roomth(const nlohmann::json & value) { this->roomth = value; }
+
+        const nlohmann::json & get_saccharose() const { return saccharose; }
+        nlohmann::json & get_mutable_saccharose() { return saccharose; }
+        void set_saccharose(const nlohmann::json & value) { this->saccharose = value; }
+
+        const nlohmann::json & get_septonasal() const { return septonasal; }
+        nlohmann::json & get_mutable_septonasal() { return septonasal; }
+        void set_septonasal(const nlohmann::json & value) { this->septonasal = value; }
+
+        const nlohmann::json & get_serpenticide() const { return serpenticide; }
+        nlohmann::json & get_mutable_serpenticide() { return serpenticide; }
+        void set_serpenticide(const nlohmann::json & value) { this->serpenticide = value; }
+
+        const nlohmann::json & get_setarious() const { return setarious; }
+        nlohmann::json & get_mutable_setarious() { return setarious; }
+        void set_setarious(const nlohmann::json & value) { this->setarious = value; }
+
+        const nlohmann::json & get_spaework() const { return spaework; }
+        nlohmann::json & get_mutable_spaework() { return spaework; }
+        void set_spaework(const nlohmann::json & value) { this->spaework = value; }
+
+        const nlohmann::json & get_stylite() const { return stylite; }
+        nlohmann::json & get_mutable_stylite() { return stylite; }
+        void set_stylite(const nlohmann::json & value) { this->stylite = value; }
+
+        const nlohmann::json & get_suessiones() const { return suessiones; }
+        nlohmann::json & get_mutable_suessiones() { return suessiones; }
+        void set_suessiones(const nlohmann::json & value) { this->suessiones = value; }
+
+        const nlohmann::json & get_timelily() const { return timelily; }
+        nlohmann::json & get_mutable_timelily() { return timelily; }
+        void set_timelily(const nlohmann::json & value) { this->timelily = value; }
+
+        const nlohmann::json & get_unprofaned() const { return unprofaned; }
+        nlohmann::json & get_mutable_unprofaned() { return unprofaned; }
+        void set_unprofaned(const nlohmann::json & value) { this->unprofaned = value; }
+
+        const nlohmann::json & get_vorticular() const { return vorticular; }
+        nlohmann::json & get_mutable_vorticular() { return vorticular; }
+        void set_vorticular(const nlohmann::json & value) { this->vorticular = value; }
+    };
+
+    using SantirElement = std::variant<SantirClass, double>;
+
+    using Saprophilous = std::optional<std::variant<std::map<std::string, int64_t>, std::string>>;
+
+    class SaxtenClass {
+        public:
+        SaxtenClass() = default;
+        virtual ~SaxtenClass() = default;
+
+        private:
+        nlohmann::json algarrobilla;
+        nlohmann::json bowgrace;
+        std::optional<double> catharticalness;
+        nlohmann::json centaurid;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        nlohmann::json flix;
+        nlohmann::json germanely;
+        std::optional<bool> homocerc;
+        nlohmann::json inhume;
+        nlohmann::json lepidote;
+        nlohmann::json megalochirous;
+        nlohmann::json ninepenny;
+        nlohmann::json nonbookish;
+        nlohmann::json nondeist;
+        nlohmann::json nymphaeaceous;
+        nlohmann::json parietofrontal;
+        nlohmann::json sancyite;
+        nlohmann::json subjectivist;
+        nlohmann::json tibiad;
+        nlohmann::json transonic;
+        nlohmann::json tripetalous;
+        nlohmann::json trunchman;
+        nlohmann::json urger;
+        nlohmann::json withdrawnness;
+
+        public:
+        const nlohmann::json & get_algarrobilla() const { return algarrobilla; }
+        nlohmann::json & get_mutable_algarrobilla() { return algarrobilla; }
+        void set_algarrobilla(const nlohmann::json & value) { this->algarrobilla = value; }
+
+        const nlohmann::json & get_bowgrace() const { return bowgrace; }
+        nlohmann::json & get_mutable_bowgrace() { return bowgrace; }
+        void set_bowgrace(const nlohmann::json & value) { this->bowgrace = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const nlohmann::json & get_centaurid() const { return centaurid; }
+        nlohmann::json & get_mutable_centaurid() { return centaurid; }
+        void set_centaurid(const nlohmann::json & value) { this->centaurid = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_flix() const { return flix; }
+        nlohmann::json & get_mutable_flix() { return flix; }
+        void set_flix(const nlohmann::json & value) { this->flix = value; }
+
+        const nlohmann::json & get_germanely() const { return germanely; }
+        nlohmann::json & get_mutable_germanely() { return germanely; }
+        void set_germanely(const nlohmann::json & value) { this->germanely = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_inhume() const { return inhume; }
+        nlohmann::json & get_mutable_inhume() { return inhume; }
+        void set_inhume(const nlohmann::json & value) { this->inhume = value; }
+
+        const nlohmann::json & get_lepidote() const { return lepidote; }
+        nlohmann::json & get_mutable_lepidote() { return lepidote; }
+        void set_lepidote(const nlohmann::json & value) { this->lepidote = value; }
+
+        const nlohmann::json & get_megalochirous() const { return megalochirous; }
+        nlohmann::json & get_mutable_megalochirous() { return megalochirous; }
+        void set_megalochirous(const nlohmann::json & value) { this->megalochirous = value; }
+
+        const nlohmann::json & get_ninepenny() const { return ninepenny; }
+        nlohmann::json & get_mutable_ninepenny() { return ninepenny; }
+        void set_ninepenny(const nlohmann::json & value) { this->ninepenny = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_nondeist() const { return nondeist; }
+        nlohmann::json & get_mutable_nondeist() { return nondeist; }
+        void set_nondeist(const nlohmann::json & value) { this->nondeist = value; }
+
+        const nlohmann::json & get_nymphaeaceous() const { return nymphaeaceous; }
+        nlohmann::json & get_mutable_nymphaeaceous() { return nymphaeaceous; }
+        void set_nymphaeaceous(const nlohmann::json & value) { this->nymphaeaceous = value; }
+
+        const nlohmann::json & get_parietofrontal() const { return parietofrontal; }
+        nlohmann::json & get_mutable_parietofrontal() { return parietofrontal; }
+        void set_parietofrontal(const nlohmann::json & value) { this->parietofrontal = value; }
+
+        const nlohmann::json & get_sancyite() const { return sancyite; }
+        nlohmann::json & get_mutable_sancyite() { return sancyite; }
+        void set_sancyite(const nlohmann::json & value) { this->sancyite = value; }
+
+        const nlohmann::json & get_subjectivist() const { return subjectivist; }
+        nlohmann::json & get_mutable_subjectivist() { return subjectivist; }
+        void set_subjectivist(const nlohmann::json & value) { this->subjectivist = value; }
+
+        const nlohmann::json & get_tibiad() const { return tibiad; }
+        nlohmann::json & get_mutable_tibiad() { return tibiad; }
+        void set_tibiad(const nlohmann::json & value) { this->tibiad = value; }
+
+        const nlohmann::json & get_transonic() const { return transonic; }
+        nlohmann::json & get_mutable_transonic() { return transonic; }
+        void set_transonic(const nlohmann::json & value) { this->transonic = value; }
+
+        const nlohmann::json & get_tripetalous() const { return tripetalous; }
+        nlohmann::json & get_mutable_tripetalous() { return tripetalous; }
+        void set_tripetalous(const nlohmann::json & value) { this->tripetalous = value; }
+
+        const nlohmann::json & get_trunchman() const { return trunchman; }
+        nlohmann::json & get_mutable_trunchman() { return trunchman; }
+        void set_trunchman(const nlohmann::json & value) { this->trunchman = value; }
+
+        const nlohmann::json & get_urger() const { return urger; }
+        nlohmann::json & get_mutable_urger() { return urger; }
+        void set_urger(const nlohmann::json & value) { this->urger = value; }
+
+        const nlohmann::json & get_withdrawnness() const { return withdrawnness; }
+        nlohmann::json & get_mutable_withdrawnness() { return withdrawnness; }
+        void set_withdrawnness(const nlohmann::json & value) { this->withdrawnness = value; }
+    };
+
+    using SaxtenElement = std::variant<SaxtenClass, std::string>;
+
+    class Scatty {
+        public:
+        Scatty() = default;
+        virtual ~Scatty() = default;
+
+        private:
+        nlohmann::json aeriferous;
+        nlohmann::json antical;
+        nlohmann::json antighostism;
+        nlohmann::json arcanum;
+        nlohmann::json autotrophy;
+        nlohmann::json baronial;
+        nlohmann::json caffeine;
+        nlohmann::json gorgoniacean;
+        nlohmann::json heroical;
+        nlohmann::json hydropical;
+        nlohmann::json mechanology;
+        nlohmann::json musicopoetic;
+        nlohmann::json officiality;
+        nlohmann::json oftentimes;
+        nlohmann::json ophthalmotonometer;
+        nlohmann::json reflectively;
+        nlohmann::json springer;
+        nlohmann::json tabasco;
+        nlohmann::json teleianthous;
+        nlohmann::json uncombated;
+
+        public:
+        const nlohmann::json & get_aeriferous() const { return aeriferous; }
+        nlohmann::json & get_mutable_aeriferous() { return aeriferous; }
+        void set_aeriferous(const nlohmann::json & value) { this->aeriferous = value; }
+
+        const nlohmann::json & get_antical() const { return antical; }
+        nlohmann::json & get_mutable_antical() { return antical; }
+        void set_antical(const nlohmann::json & value) { this->antical = value; }
+
+        const nlohmann::json & get_antighostism() const { return antighostism; }
+        nlohmann::json & get_mutable_antighostism() { return antighostism; }
+        void set_antighostism(const nlohmann::json & value) { this->antighostism = value; }
+
+        const nlohmann::json & get_arcanum() const { return arcanum; }
+        nlohmann::json & get_mutable_arcanum() { return arcanum; }
+        void set_arcanum(const nlohmann::json & value) { this->arcanum = value; }
+
+        const nlohmann::json & get_autotrophy() const { return autotrophy; }
+        nlohmann::json & get_mutable_autotrophy() { return autotrophy; }
+        void set_autotrophy(const nlohmann::json & value) { this->autotrophy = value; }
+
+        const nlohmann::json & get_baronial() const { return baronial; }
+        nlohmann::json & get_mutable_baronial() { return baronial; }
+        void set_baronial(const nlohmann::json & value) { this->baronial = value; }
+
+        const nlohmann::json & get_caffeine() const { return caffeine; }
+        nlohmann::json & get_mutable_caffeine() { return caffeine; }
+        void set_caffeine(const nlohmann::json & value) { this->caffeine = value; }
+
+        const nlohmann::json & get_gorgoniacean() const { return gorgoniacean; }
+        nlohmann::json & get_mutable_gorgoniacean() { return gorgoniacean; }
+        void set_gorgoniacean(const nlohmann::json & value) { this->gorgoniacean = value; }
+
+        const nlohmann::json & get_heroical() const { return heroical; }
+        nlohmann::json & get_mutable_heroical() { return heroical; }
+        void set_heroical(const nlohmann::json & value) { this->heroical = value; }
+
+        const nlohmann::json & get_hydropical() const { return hydropical; }
+        nlohmann::json & get_mutable_hydropical() { return hydropical; }
+        void set_hydropical(const nlohmann::json & value) { this->hydropical = value; }
+
+        const nlohmann::json & get_mechanology() const { return mechanology; }
+        nlohmann::json & get_mutable_mechanology() { return mechanology; }
+        void set_mechanology(const nlohmann::json & value) { this->mechanology = value; }
+
+        const nlohmann::json & get_musicopoetic() const { return musicopoetic; }
+        nlohmann::json & get_mutable_musicopoetic() { return musicopoetic; }
+        void set_musicopoetic(const nlohmann::json & value) { this->musicopoetic = value; }
+
+        const nlohmann::json & get_officiality() const { return officiality; }
+        nlohmann::json & get_mutable_officiality() { return officiality; }
+        void set_officiality(const nlohmann::json & value) { this->officiality = value; }
+
+        const nlohmann::json & get_oftentimes() const { return oftentimes; }
+        nlohmann::json & get_mutable_oftentimes() { return oftentimes; }
+        void set_oftentimes(const nlohmann::json & value) { this->oftentimes = value; }
+
+        const nlohmann::json & get_ophthalmotonometer() const { return ophthalmotonometer; }
+        nlohmann::json & get_mutable_ophthalmotonometer() { return ophthalmotonometer; }
+        void set_ophthalmotonometer(const nlohmann::json & value) { this->ophthalmotonometer = value; }
+
+        const nlohmann::json & get_reflectively() const { return reflectively; }
+        nlohmann::json & get_mutable_reflectively() { return reflectively; }
+        void set_reflectively(const nlohmann::json & value) { this->reflectively = value; }
+
+        const nlohmann::json & get_springer() const { return springer; }
+        nlohmann::json & get_mutable_springer() { return springer; }
+        void set_springer(const nlohmann::json & value) { this->springer = value; }
+
+        const nlohmann::json & get_tabasco() const { return tabasco; }
+        nlohmann::json & get_mutable_tabasco() { return tabasco; }
+        void set_tabasco(const nlohmann::json & value) { this->tabasco = value; }
+
+        const nlohmann::json & get_teleianthous() const { return teleianthous; }
+        nlohmann::json & get_mutable_teleianthous() { return teleianthous; }
+        void set_teleianthous(const nlohmann::json & value) { this->teleianthous = value; }
+
+        const nlohmann::json & get_uncombated() const { return uncombated; }
+        nlohmann::json & get_mutable_uncombated() { return uncombated; }
+        void set_uncombated(const nlohmann::json & value) { this->uncombated = value; }
+    };
+
+    using Scoffer = std::optional<std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>>>;
+
+    using Scrampum = std::optional<std::variant<std::vector<int64_t>, bool>>;
+
+    using Serpentinic = std::variant<std::vector<int64_t>, double>;
+
+    using Shadowable = std::variant<std::vector<std::optional<int64_t>>, bool>;
+
+    class SisteringClass {
+        public:
+        SisteringClass() = default;
+        virtual ~SisteringClass() = default;
+
+        private:
+        nlohmann::json amphicarpic;
+        nlohmann::json chianti;
+        nlohmann::json frigorific;
+        nlohmann::json haplomi;
+        nlohmann::json hyperkinesis;
+        nlohmann::json laudable;
+        nlohmann::json madwoman;
+        nlohmann::json maimedly;
+        nlohmann::json micropterygidae;
+        nlohmann::json microrhabdus;
+        nlohmann::json nondense;
+        nlohmann::json phlebemphraxis;
+        nlohmann::json redsear;
+        nlohmann::json schismatical;
+        nlohmann::json tartryl;
+        nlohmann::json unabhorred;
+        nlohmann::json undeliberateness;
+        nlohmann::json unmixable;
+        nlohmann::json untruckling;
+        nlohmann::json vineal;
+
+        public:
+        const nlohmann::json & get_amphicarpic() const { return amphicarpic; }
+        nlohmann::json & get_mutable_amphicarpic() { return amphicarpic; }
+        void set_amphicarpic(const nlohmann::json & value) { this->amphicarpic = value; }
+
+        const nlohmann::json & get_chianti() const { return chianti; }
+        nlohmann::json & get_mutable_chianti() { return chianti; }
+        void set_chianti(const nlohmann::json & value) { this->chianti = value; }
+
+        const nlohmann::json & get_frigorific() const { return frigorific; }
+        nlohmann::json & get_mutable_frigorific() { return frigorific; }
+        void set_frigorific(const nlohmann::json & value) { this->frigorific = value; }
+
+        const nlohmann::json & get_haplomi() const { return haplomi; }
+        nlohmann::json & get_mutable_haplomi() { return haplomi; }
+        void set_haplomi(const nlohmann::json & value) { this->haplomi = value; }
+
+        const nlohmann::json & get_hyperkinesis() const { return hyperkinesis; }
+        nlohmann::json & get_mutable_hyperkinesis() { return hyperkinesis; }
+        void set_hyperkinesis(const nlohmann::json & value) { this->hyperkinesis = value; }
+
+        const nlohmann::json & get_laudable() const { return laudable; }
+        nlohmann::json & get_mutable_laudable() { return laudable; }
+        void set_laudable(const nlohmann::json & value) { this->laudable = value; }
+
+        const nlohmann::json & get_madwoman() const { return madwoman; }
+        nlohmann::json & get_mutable_madwoman() { return madwoman; }
+        void set_madwoman(const nlohmann::json & value) { this->madwoman = value; }
+
+        const nlohmann::json & get_maimedly() const { return maimedly; }
+        nlohmann::json & get_mutable_maimedly() { return maimedly; }
+        void set_maimedly(const nlohmann::json & value) { this->maimedly = value; }
+
+        const nlohmann::json & get_micropterygidae() const { return micropterygidae; }
+        nlohmann::json & get_mutable_micropterygidae() { return micropterygidae; }
+        void set_micropterygidae(const nlohmann::json & value) { this->micropterygidae = value; }
+
+        const nlohmann::json & get_microrhabdus() const { return microrhabdus; }
+        nlohmann::json & get_mutable_microrhabdus() { return microrhabdus; }
+        void set_microrhabdus(const nlohmann::json & value) { this->microrhabdus = value; }
+
+        const nlohmann::json & get_nondense() const { return nondense; }
+        nlohmann::json & get_mutable_nondense() { return nondense; }
+        void set_nondense(const nlohmann::json & value) { this->nondense = value; }
+
+        const nlohmann::json & get_phlebemphraxis() const { return phlebemphraxis; }
+        nlohmann::json & get_mutable_phlebemphraxis() { return phlebemphraxis; }
+        void set_phlebemphraxis(const nlohmann::json & value) { this->phlebemphraxis = value; }
+
+        const nlohmann::json & get_redsear() const { return redsear; }
+        nlohmann::json & get_mutable_redsear() { return redsear; }
+        void set_redsear(const nlohmann::json & value) { this->redsear = value; }
+
+        const nlohmann::json & get_schismatical() const { return schismatical; }
+        nlohmann::json & get_mutable_schismatical() { return schismatical; }
+        void set_schismatical(const nlohmann::json & value) { this->schismatical = value; }
+
+        const nlohmann::json & get_tartryl() const { return tartryl; }
+        nlohmann::json & get_mutable_tartryl() { return tartryl; }
+        void set_tartryl(const nlohmann::json & value) { this->tartryl = value; }
+
+        const nlohmann::json & get_unabhorred() const { return unabhorred; }
+        nlohmann::json & get_mutable_unabhorred() { return unabhorred; }
+        void set_unabhorred(const nlohmann::json & value) { this->unabhorred = value; }
+
+        const nlohmann::json & get_undeliberateness() const { return undeliberateness; }
+        nlohmann::json & get_mutable_undeliberateness() { return undeliberateness; }
+        void set_undeliberateness(const nlohmann::json & value) { this->undeliberateness = value; }
+
+        const nlohmann::json & get_unmixable() const { return unmixable; }
+        nlohmann::json & get_mutable_unmixable() { return unmixable; }
+        void set_unmixable(const nlohmann::json & value) { this->unmixable = value; }
+
+        const nlohmann::json & get_untruckling() const { return untruckling; }
+        nlohmann::json & get_mutable_untruckling() { return untruckling; }
+        void set_untruckling(const nlohmann::json & value) { this->untruckling = value; }
+
+        const nlohmann::json & get_vineal() const { return vineal; }
+        nlohmann::json & get_mutable_vineal() { return vineal; }
+        void set_vineal(const nlohmann::json & value) { this->vineal = value; }
+    };
+
+    using SisteringElement = std::variant<std::vector<nlohmann::json>, SisteringClass, int64_t>;
+
+    class Staghunting {
+        public:
+        Staghunting() = default;
+        virtual ~Staghunting() = default;
+
+        private:
+        std::optional<int64_t> calorimetric;
+        std::optional<int64_t> canid;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ditriglyphic;
+        std::optional<int64_t> floriferousness;
+        std::optional<int64_t> gamelike;
+        std::optional<int64_t> grig;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> interloan;
+        std::optional<int64_t> lithotomy;
+        std::optional<int64_t> loric;
+        std::optional<int64_t> membranocoriaceous;
+        std::optional<int64_t> membranogenic;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> overtrump;
+        std::optional<int64_t> scotino;
+        std::optional<int64_t> seasonable;
+        std::optional<int64_t> sephen;
+        std::optional<int64_t> stigmarioid;
+        std::optional<int64_t> tired;
+        std::optional<int64_t> trifid;
+        std::optional<int64_t> undefeatedly;
+        std::optional<int64_t> ungirlish;
+
+        public:
+        const std::optional<int64_t> & get_calorimetric() const { return calorimetric; }
+        std::optional<int64_t> & get_mutable_calorimetric() { return calorimetric; }
+        void set_calorimetric(const std::optional<int64_t> & value) { this->calorimetric = value; }
+
+        const std::optional<int64_t> & get_canid() const { return canid; }
+        std::optional<int64_t> & get_mutable_canid() { return canid; }
+        void set_canid(const std::optional<int64_t> & value) { this->canid = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_ditriglyphic() const { return ditriglyphic; }
+        std::optional<int64_t> & get_mutable_ditriglyphic() { return ditriglyphic; }
+        void set_ditriglyphic(const std::optional<int64_t> & value) { this->ditriglyphic = value; }
+
+        const std::optional<int64_t> & get_floriferousness() const { return floriferousness; }
+        std::optional<int64_t> & get_mutable_floriferousness() { return floriferousness; }
+        void set_floriferousness(const std::optional<int64_t> & value) { this->floriferousness = value; }
+
+        const std::optional<int64_t> & get_gamelike() const { return gamelike; }
+        std::optional<int64_t> & get_mutable_gamelike() { return gamelike; }
+        void set_gamelike(const std::optional<int64_t> & value) { this->gamelike = value; }
+
+        const std::optional<int64_t> & get_grig() const { return grig; }
+        std::optional<int64_t> & get_mutable_grig() { return grig; }
+        void set_grig(const std::optional<int64_t> & value) { this->grig = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_interloan() const { return interloan; }
+        std::optional<int64_t> & get_mutable_interloan() { return interloan; }
+        void set_interloan(const std::optional<int64_t> & value) { this->interloan = value; }
+
+        const std::optional<int64_t> & get_lithotomy() const { return lithotomy; }
+        std::optional<int64_t> & get_mutable_lithotomy() { return lithotomy; }
+        void set_lithotomy(const std::optional<int64_t> & value) { this->lithotomy = value; }
+
+        const std::optional<int64_t> & get_loric() const { return loric; }
+        std::optional<int64_t> & get_mutable_loric() { return loric; }
+        void set_loric(const std::optional<int64_t> & value) { this->loric = value; }
+
+        const std::optional<int64_t> & get_membranocoriaceous() const { return membranocoriaceous; }
+        std::optional<int64_t> & get_mutable_membranocoriaceous() { return membranocoriaceous; }
+        void set_membranocoriaceous(const std::optional<int64_t> & value) { this->membranocoriaceous = value; }
+
+        const std::optional<int64_t> & get_membranogenic() const { return membranogenic; }
+        std::optional<int64_t> & get_mutable_membranogenic() { return membranogenic; }
+        void set_membranogenic(const std::optional<int64_t> & value) { this->membranogenic = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_overtrump() const { return overtrump; }
+        std::optional<int64_t> & get_mutable_overtrump() { return overtrump; }
+        void set_overtrump(const std::optional<int64_t> & value) { this->overtrump = value; }
+
+        const std::optional<int64_t> & get_scotino() const { return scotino; }
+        std::optional<int64_t> & get_mutable_scotino() { return scotino; }
+        void set_scotino(const std::optional<int64_t> & value) { this->scotino = value; }
+
+        const std::optional<int64_t> & get_seasonable() const { return seasonable; }
+        std::optional<int64_t> & get_mutable_seasonable() { return seasonable; }
+        void set_seasonable(const std::optional<int64_t> & value) { this->seasonable = value; }
+
+        const std::optional<int64_t> & get_sephen() const { return sephen; }
+        std::optional<int64_t> & get_mutable_sephen() { return sephen; }
+        void set_sephen(const std::optional<int64_t> & value) { this->sephen = value; }
+
+        const std::optional<int64_t> & get_stigmarioid() const { return stigmarioid; }
+        std::optional<int64_t> & get_mutable_stigmarioid() { return stigmarioid; }
+        void set_stigmarioid(const std::optional<int64_t> & value) { this->stigmarioid = value; }
+
+        const std::optional<int64_t> & get_tired() const { return tired; }
+        std::optional<int64_t> & get_mutable_tired() { return tired; }
+        void set_tired(const std::optional<int64_t> & value) { this->tired = value; }
+
+        const std::optional<int64_t> & get_trifid() const { return trifid; }
+        std::optional<int64_t> & get_mutable_trifid() { return trifid; }
+        void set_trifid(const std::optional<int64_t> & value) { this->trifid = value; }
+
+        const std::optional<int64_t> & get_undefeatedly() const { return undefeatedly; }
+        std::optional<int64_t> & get_mutable_undefeatedly() { return undefeatedly; }
+        void set_undefeatedly(const std::optional<int64_t> & value) { this->undefeatedly = value; }
+
+        const std::optional<int64_t> & get_ungirlish() const { return ungirlish; }
+        std::optional<int64_t> & get_mutable_ungirlish() { return ungirlish; }
+        void set_ungirlish(const std::optional<int64_t> & value) { this->ungirlish = value; }
+    };
+
+    using Stagmometer = std::variant<std::vector<std::optional<int64_t>>, std::string>;
+
+    using Stimulability = std::variant<bool, int64_t, std::map<std::string, int64_t>>;
+
+    using Strangleable = std::variant<std::vector<nlohmann::json>, double>;
+
+    class StrenuosityClass {
+        public:
+        StrenuosityClass() = default;
+        virtual ~StrenuosityClass() = default;
+
+        private:
+        std::optional<int64_t> bliss;
+        std::optional<int64_t> buccate;
+        std::optional<int64_t> bulletproof;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> crumblingness;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> engagedly;
+        std::optional<int64_t> fightable;
+        std::optional<int64_t> hoariness;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> hypopodium;
+        std::optional<int64_t> luxurist;
+        std::optional<int64_t> mechanician;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> onopordon;
+        std::optional<int64_t> podgily;
+        std::optional<int64_t> reformableness;
+        std::optional<int64_t> scatterbrains;
+        std::optional<int64_t> seminuria;
+        std::optional<int64_t> sodomite;
+        std::optional<int64_t> tramp;
+        std::optional<int64_t> undueness;
+        std::optional<int64_t> worthily;
+        std::optional<int64_t> yankeeist;
+
+        public:
+        const std::optional<int64_t> & get_bliss() const { return bliss; }
+        std::optional<int64_t> & get_mutable_bliss() { return bliss; }
+        void set_bliss(const std::optional<int64_t> & value) { this->bliss = value; }
+
+        const std::optional<int64_t> & get_buccate() const { return buccate; }
+        std::optional<int64_t> & get_mutable_buccate() { return buccate; }
+        void set_buccate(const std::optional<int64_t> & value) { this->buccate = value; }
+
+        const std::optional<int64_t> & get_bulletproof() const { return bulletproof; }
+        std::optional<int64_t> & get_mutable_bulletproof() { return bulletproof; }
+        void set_bulletproof(const std::optional<int64_t> & value) { this->bulletproof = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_crumblingness() const { return crumblingness; }
+        std::optional<int64_t> & get_mutable_crumblingness() { return crumblingness; }
+        void set_crumblingness(const std::optional<int64_t> & value) { this->crumblingness = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_engagedly() const { return engagedly; }
+        std::optional<int64_t> & get_mutable_engagedly() { return engagedly; }
+        void set_engagedly(const std::optional<int64_t> & value) { this->engagedly = value; }
+
+        const std::optional<int64_t> & get_fightable() const { return fightable; }
+        std::optional<int64_t> & get_mutable_fightable() { return fightable; }
+        void set_fightable(const std::optional<int64_t> & value) { this->fightable = value; }
+
+        const std::optional<int64_t> & get_hoariness() const { return hoariness; }
+        std::optional<int64_t> & get_mutable_hoariness() { return hoariness; }
+        void set_hoariness(const std::optional<int64_t> & value) { this->hoariness = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_hypopodium() const { return hypopodium; }
+        std::optional<int64_t> & get_mutable_hypopodium() { return hypopodium; }
+        void set_hypopodium(const std::optional<int64_t> & value) { this->hypopodium = value; }
+
+        const std::optional<int64_t> & get_luxurist() const { return luxurist; }
+        std::optional<int64_t> & get_mutable_luxurist() { return luxurist; }
+        void set_luxurist(const std::optional<int64_t> & value) { this->luxurist = value; }
+
+        const std::optional<int64_t> & get_mechanician() const { return mechanician; }
+        std::optional<int64_t> & get_mutable_mechanician() { return mechanician; }
+        void set_mechanician(const std::optional<int64_t> & value) { this->mechanician = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_onopordon() const { return onopordon; }
+        std::optional<int64_t> & get_mutable_onopordon() { return onopordon; }
+        void set_onopordon(const std::optional<int64_t> & value) { this->onopordon = value; }
+
+        const std::optional<int64_t> & get_podgily() const { return podgily; }
+        std::optional<int64_t> & get_mutable_podgily() { return podgily; }
+        void set_podgily(const std::optional<int64_t> & value) { this->podgily = value; }
+
+        const std::optional<int64_t> & get_reformableness() const { return reformableness; }
+        std::optional<int64_t> & get_mutable_reformableness() { return reformableness; }
+        void set_reformableness(const std::optional<int64_t> & value) { this->reformableness = value; }
+
+        const std::optional<int64_t> & get_scatterbrains() const { return scatterbrains; }
+        std::optional<int64_t> & get_mutable_scatterbrains() { return scatterbrains; }
+        void set_scatterbrains(const std::optional<int64_t> & value) { this->scatterbrains = value; }
+
+        const std::optional<int64_t> & get_seminuria() const { return seminuria; }
+        std::optional<int64_t> & get_mutable_seminuria() { return seminuria; }
+        void set_seminuria(const std::optional<int64_t> & value) { this->seminuria = value; }
+
+        const std::optional<int64_t> & get_sodomite() const { return sodomite; }
+        std::optional<int64_t> & get_mutable_sodomite() { return sodomite; }
+        void set_sodomite(const std::optional<int64_t> & value) { this->sodomite = value; }
+
+        const std::optional<int64_t> & get_tramp() const { return tramp; }
+        std::optional<int64_t> & get_mutable_tramp() { return tramp; }
+        void set_tramp(const std::optional<int64_t> & value) { this->tramp = value; }
+
+        const std::optional<int64_t> & get_undueness() const { return undueness; }
+        std::optional<int64_t> & get_mutable_undueness() { return undueness; }
+        void set_undueness(const std::optional<int64_t> & value) { this->undueness = value; }
+
+        const std::optional<int64_t> & get_worthily() const { return worthily; }
+        std::optional<int64_t> & get_mutable_worthily() { return worthily; }
+        void set_worthily(const std::optional<int64_t> & value) { this->worthily = value; }
+
+        const std::optional<int64_t> & get_yankeeist() const { return yankeeist; }
+        std::optional<int64_t> & get_mutable_yankeeist() { return yankeeist; }
+        void set_yankeeist(const std::optional<int64_t> & value) { this->yankeeist = value; }
+    };
+
+    using StrenuosityElement = std::variant<std::vector<nlohmann::json>, StrenuosityClass>;
+
+    using Tabaxir = std::variant<bool, double>;
+
+    using Talpiform = std::optional<std::variant<QuebrachineClass, double>>;
+
+    using Thwack = std::variant<bool, QuebrachineClass, double>;
+
+    using Tortricine = std::variant<std::vector<std::optional<int64_t>>, QuebrachineClass>;
+
+    class TruantcyClass {
+        public:
+        TruantcyClass() = default;
+        virtual ~TruantcyClass() = default;
+
+        private:
+        nlohmann::json alfiona;
+        nlohmann::json ascaridiasis;
+        nlohmann::json bungey;
+        std::optional<double> catharticalness;
+        nlohmann::json ceroxyle;
+        std::optional<int64_t> chirotherium;
+        nlohmann::json chorology;
+        std::optional<std::string> disdiapason;
+        nlohmann::json enmarble;
+        nlohmann::json epeira;
+        nlohmann::json eurylaimi;
+        nlohmann::json germination;
+        nlohmann::json hallelujah;
+        std::optional<bool> homocerc;
+        nlohmann::json lev;
+        nlohmann::json mouthing;
+        nlohmann::json nonbookish;
+        nlohmann::json philliloo;
+        nlohmann::json planetal;
+        nlohmann::json poney;
+        nlohmann::json punctualist;
+        nlohmann::json returnlessly;
+        nlohmann::json skelder;
+        nlohmann::json windwaywardly;
+        nlohmann::json yuman;
+
+        public:
+        const nlohmann::json & get_alfiona() const { return alfiona; }
+        nlohmann::json & get_mutable_alfiona() { return alfiona; }
+        void set_alfiona(const nlohmann::json & value) { this->alfiona = value; }
+
+        const nlohmann::json & get_ascaridiasis() const { return ascaridiasis; }
+        nlohmann::json & get_mutable_ascaridiasis() { return ascaridiasis; }
+        void set_ascaridiasis(const nlohmann::json & value) { this->ascaridiasis = value; }
+
+        const nlohmann::json & get_bungey() const { return bungey; }
+        nlohmann::json & get_mutable_bungey() { return bungey; }
+        void set_bungey(const nlohmann::json & value) { this->bungey = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const nlohmann::json & get_ceroxyle() const { return ceroxyle; }
+        nlohmann::json & get_mutable_ceroxyle() { return ceroxyle; }
+        void set_ceroxyle(const nlohmann::json & value) { this->ceroxyle = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const nlohmann::json & get_chorology() const { return chorology; }
+        nlohmann::json & get_mutable_chorology() { return chorology; }
+        void set_chorology(const nlohmann::json & value) { this->chorology = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const nlohmann::json & get_enmarble() const { return enmarble; }
+        nlohmann::json & get_mutable_enmarble() { return enmarble; }
+        void set_enmarble(const nlohmann::json & value) { this->enmarble = value; }
+
+        const nlohmann::json & get_epeira() const { return epeira; }
+        nlohmann::json & get_mutable_epeira() { return epeira; }
+        void set_epeira(const nlohmann::json & value) { this->epeira = value; }
+
+        const nlohmann::json & get_eurylaimi() const { return eurylaimi; }
+        nlohmann::json & get_mutable_eurylaimi() { return eurylaimi; }
+        void set_eurylaimi(const nlohmann::json & value) { this->eurylaimi = value; }
+
+        const nlohmann::json & get_germination() const { return germination; }
+        nlohmann::json & get_mutable_germination() { return germination; }
+        void set_germination(const nlohmann::json & value) { this->germination = value; }
+
+        const nlohmann::json & get_hallelujah() const { return hallelujah; }
+        nlohmann::json & get_mutable_hallelujah() { return hallelujah; }
+        void set_hallelujah(const nlohmann::json & value) { this->hallelujah = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const nlohmann::json & get_lev() const { return lev; }
+        nlohmann::json & get_mutable_lev() { return lev; }
+        void set_lev(const nlohmann::json & value) { this->lev = value; }
+
+        const nlohmann::json & get_mouthing() const { return mouthing; }
+        nlohmann::json & get_mutable_mouthing() { return mouthing; }
+        void set_mouthing(const nlohmann::json & value) { this->mouthing = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const nlohmann::json & get_philliloo() const { return philliloo; }
+        nlohmann::json & get_mutable_philliloo() { return philliloo; }
+        void set_philliloo(const nlohmann::json & value) { this->philliloo = value; }
+
+        const nlohmann::json & get_planetal() const { return planetal; }
+        nlohmann::json & get_mutable_planetal() { return planetal; }
+        void set_planetal(const nlohmann::json & value) { this->planetal = value; }
+
+        const nlohmann::json & get_poney() const { return poney; }
+        nlohmann::json & get_mutable_poney() { return poney; }
+        void set_poney(const nlohmann::json & value) { this->poney = value; }
+
+        const nlohmann::json & get_punctualist() const { return punctualist; }
+        nlohmann::json & get_mutable_punctualist() { return punctualist; }
+        void set_punctualist(const nlohmann::json & value) { this->punctualist = value; }
+
+        const nlohmann::json & get_returnlessly() const { return returnlessly; }
+        nlohmann::json & get_mutable_returnlessly() { return returnlessly; }
+        void set_returnlessly(const nlohmann::json & value) { this->returnlessly = value; }
+
+        const nlohmann::json & get_skelder() const { return skelder; }
+        nlohmann::json & get_mutable_skelder() { return skelder; }
+        void set_skelder(const nlohmann::json & value) { this->skelder = value; }
+
+        const nlohmann::json & get_windwaywardly() const { return windwaywardly; }
+        nlohmann::json & get_mutable_windwaywardly() { return windwaywardly; }
+        void set_windwaywardly(const nlohmann::json & value) { this->windwaywardly = value; }
+
+        const nlohmann::json & get_yuman() const { return yuman; }
+        nlohmann::json & get_mutable_yuman() { return yuman; }
+        void set_yuman(const nlohmann::json & value) { this->yuman = value; }
+    };
+
+    using TruantcyElement = std::variant<bool, TruantcyClass>;
+
+    using Unbeginning = std::variant<std::vector<nlohmann::json>, std::map<std::string, int64_t>, std::string>;
+
+    using Undesirability = std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>;
+
+    using Unerasing = std::variant<std::vector<nlohmann::json>, int64_t, std::map<std::string, int64_t>>;
+
+    using Unguentarium = std::optional<std::variant<std::vector<nlohmann::json>, int64_t>>;
+
+    class UnimpeachablyClass {
+        public:
+        UnimpeachablyClass() = default;
+        virtual ~UnimpeachablyClass() = default;
+
+        private:
+        std::optional<int64_t> acerin;
+        std::optional<int64_t> bobadil;
+        std::optional<double> catharticalness;
+        std::optional<int64_t> chirotherium;
+        std::optional<int64_t> chlorophylligenous;
+        std::optional<int64_t> conversational;
+        std::optional<int64_t> demiowl;
+        std::optional<std::string> disdiapason;
+        std::optional<int64_t> ectorhinal;
+        std::optional<int64_t> gamblesomeness;
+        std::optional<bool> homocerc;
+        std::optional<int64_t> irrorate;
+        std::optional<int64_t> kindergartening;
+        std::optional<int64_t> lateritic;
+        std::optional<int64_t> mespil;
+        std::optional<int64_t> misconfiguration;
+        nlohmann::json nonbookish;
+        std::optional<int64_t> planometry;
+        std::optional<int64_t> quiina;
+        std::optional<int64_t> robert;
+        std::optional<int64_t> rot;
+        std::optional<int64_t> subcinctorium;
+        std::optional<int64_t> tussocker;
+        std::optional<int64_t> ultraproud;
+        std::optional<int64_t> unsuggestedness;
+
+        public:
+        const std::optional<int64_t> & get_acerin() const { return acerin; }
+        std::optional<int64_t> & get_mutable_acerin() { return acerin; }
+        void set_acerin(const std::optional<int64_t> & value) { this->acerin = value; }
+
+        const std::optional<int64_t> & get_bobadil() const { return bobadil; }
+        std::optional<int64_t> & get_mutable_bobadil() { return bobadil; }
+        void set_bobadil(const std::optional<int64_t> & value) { this->bobadil = value; }
+
+        const std::optional<double> & get_catharticalness() const { return catharticalness; }
+        std::optional<double> & get_mutable_catharticalness() { return catharticalness; }
+        void set_catharticalness(const std::optional<double> & value) { this->catharticalness = value; }
+
+        const std::optional<int64_t> & get_chirotherium() const { return chirotherium; }
+        std::optional<int64_t> & get_mutable_chirotherium() { return chirotherium; }
+        void set_chirotherium(const std::optional<int64_t> & value) { this->chirotherium = value; }
+
+        const std::optional<int64_t> & get_chlorophylligenous() const { return chlorophylligenous; }
+        std::optional<int64_t> & get_mutable_chlorophylligenous() { return chlorophylligenous; }
+        void set_chlorophylligenous(const std::optional<int64_t> & value) { this->chlorophylligenous = value; }
+
+        const std::optional<int64_t> & get_conversational() const { return conversational; }
+        std::optional<int64_t> & get_mutable_conversational() { return conversational; }
+        void set_conversational(const std::optional<int64_t> & value) { this->conversational = value; }
+
+        const std::optional<int64_t> & get_demiowl() const { return demiowl; }
+        std::optional<int64_t> & get_mutable_demiowl() { return demiowl; }
+        void set_demiowl(const std::optional<int64_t> & value) { this->demiowl = value; }
+
+        const std::optional<std::string> & get_disdiapason() const { return disdiapason; }
+        std::optional<std::string> & get_mutable_disdiapason() { return disdiapason; }
+        void set_disdiapason(const std::optional<std::string> & value) { this->disdiapason = value; }
+
+        const std::optional<int64_t> & get_ectorhinal() const { return ectorhinal; }
+        std::optional<int64_t> & get_mutable_ectorhinal() { return ectorhinal; }
+        void set_ectorhinal(const std::optional<int64_t> & value) { this->ectorhinal = value; }
+
+        const std::optional<int64_t> & get_gamblesomeness() const { return gamblesomeness; }
+        std::optional<int64_t> & get_mutable_gamblesomeness() { return gamblesomeness; }
+        void set_gamblesomeness(const std::optional<int64_t> & value) { this->gamblesomeness = value; }
+
+        const std::optional<bool> & get_homocerc() const { return homocerc; }
+        std::optional<bool> & get_mutable_homocerc() { return homocerc; }
+        void set_homocerc(const std::optional<bool> & value) { this->homocerc = value; }
+
+        const std::optional<int64_t> & get_irrorate() const { return irrorate; }
+        std::optional<int64_t> & get_mutable_irrorate() { return irrorate; }
+        void set_irrorate(const std::optional<int64_t> & value) { this->irrorate = value; }
+
+        const std::optional<int64_t> & get_kindergartening() const { return kindergartening; }
+        std::optional<int64_t> & get_mutable_kindergartening() { return kindergartening; }
+        void set_kindergartening(const std::optional<int64_t> & value) { this->kindergartening = value; }
+
+        const std::optional<int64_t> & get_lateritic() const { return lateritic; }
+        std::optional<int64_t> & get_mutable_lateritic() { return lateritic; }
+        void set_lateritic(const std::optional<int64_t> & value) { this->lateritic = value; }
+
+        const std::optional<int64_t> & get_mespil() const { return mespil; }
+        std::optional<int64_t> & get_mutable_mespil() { return mespil; }
+        void set_mespil(const std::optional<int64_t> & value) { this->mespil = value; }
+
+        const std::optional<int64_t> & get_misconfiguration() const { return misconfiguration; }
+        std::optional<int64_t> & get_mutable_misconfiguration() { return misconfiguration; }
+        void set_misconfiguration(const std::optional<int64_t> & value) { this->misconfiguration = value; }
+
+        const nlohmann::json & get_nonbookish() const { return nonbookish; }
+        nlohmann::json & get_mutable_nonbookish() { return nonbookish; }
+        void set_nonbookish(const nlohmann::json & value) { this->nonbookish = value; }
+
+        const std::optional<int64_t> & get_planometry() const { return planometry; }
+        std::optional<int64_t> & get_mutable_planometry() { return planometry; }
+        void set_planometry(const std::optional<int64_t> & value) { this->planometry = value; }
+
+        const std::optional<int64_t> & get_quiina() const { return quiina; }
+        std::optional<int64_t> & get_mutable_quiina() { return quiina; }
+        void set_quiina(const std::optional<int64_t> & value) { this->quiina = value; }
+
+        const std::optional<int64_t> & get_robert() const { return robert; }
+        std::optional<int64_t> & get_mutable_robert() { return robert; }
+        void set_robert(const std::optional<int64_t> & value) { this->robert = value; }
+
+        const std::optional<int64_t> & get_rot() const { return rot; }
+        std::optional<int64_t> & get_mutable_rot() { return rot; }
+        void set_rot(const std::optional<int64_t> & value) { this->rot = value; }
+
+        const std::optional<int64_t> & get_subcinctorium() const { return subcinctorium; }
+        std::optional<int64_t> & get_mutable_subcinctorium() { return subcinctorium; }
+        void set_subcinctorium(const std::optional<int64_t> & value) { this->subcinctorium = value; }
+
+        const std::optional<int64_t> & get_tussocker() const { return tussocker; }
+        std::optional<int64_t> & get_mutable_tussocker() { return tussocker; }
+        void set_tussocker(const std::optional<int64_t> & value) { this->tussocker = value; }
+
+        const std::optional<int64_t> & get_ultraproud() const { return ultraproud; }
+        std::optional<int64_t> & get_mutable_ultraproud() { return ultraproud; }
+        void set_ultraproud(const std::optional<int64_t> & value) { this->ultraproud = value; }
+
+        const std::optional<int64_t> & get_unsuggestedness() const { return unsuggestedness; }
+        std::optional<int64_t> & get_mutable_unsuggestedness() { return unsuggestedness; }
+        void set_unsuggestedness(const std::optional<int64_t> & value) { this->unsuggestedness = value; }
+    };
+
+    using UnimpeachablyElement = std::variant<bool, UnimpeachablyClass>;
+
+    using Unmortgaged = std::optional<std::variant<double, std::map<std::string, int64_t>>>;
+
+    using Unobstructed = std::optional<std::variant<QuebrachineClass, int64_t>>;
+
+    using Unreceptivity = std::variant<std::vector<nlohmann::json>, int64_t, std::string>;
+
+    using Unsatisfactoriness = std::variant<std::vector<int64_t>, bool, int64_t>;
+
+    class UnstressedClass {
+        public:
+        UnstressedClass() = default;
+        virtual ~UnstressedClass() = default;
+
+        private:
+        nlohmann::json alain;
+        nlohmann::json amphirhina;
+        nlohmann::json antimachinery;
+        nlohmann::json coldish;
+        nlohmann::json crantara;
+        nlohmann::json distinguishing;
+        nlohmann::json elytroposis;
+        nlohmann::json gentianwort;
+        nlohmann::json heliosis;
+        nlohmann::json instrumental;
+        nlohmann::json introinflection;
+        nlohmann::json kala;
+        nlohmann::json lincolnian;
+        nlohmann::json metad;
+        nlohmann::json sarcophilus;
+        nlohmann::json swingingly;
+        nlohmann::json unconformity;
+        nlohmann::json undecreed;
+        nlohmann::json venerable;
+        nlohmann::json vowellessness;
+
+        public:
+        const nlohmann::json & get_alain() const { return alain; }
+        nlohmann::json & get_mutable_alain() { return alain; }
+        void set_alain(const nlohmann::json & value) { this->alain = value; }
+
+        const nlohmann::json & get_amphirhina() const { return amphirhina; }
+        nlohmann::json & get_mutable_amphirhina() { return amphirhina; }
+        void set_amphirhina(const nlohmann::json & value) { this->amphirhina = value; }
+
+        const nlohmann::json & get_antimachinery() const { return antimachinery; }
+        nlohmann::json & get_mutable_antimachinery() { return antimachinery; }
+        void set_antimachinery(const nlohmann::json & value) { this->antimachinery = value; }
+
+        const nlohmann::json & get_coldish() const { return coldish; }
+        nlohmann::json & get_mutable_coldish() { return coldish; }
+        void set_coldish(const nlohmann::json & value) { this->coldish = value; }
+
+        const nlohmann::json & get_crantara() const { return crantara; }
+        nlohmann::json & get_mutable_crantara() { return crantara; }
+        void set_crantara(const nlohmann::json & value) { this->crantara = value; }
+
+        const nlohmann::json & get_distinguishing() const { return distinguishing; }
+        nlohmann::json & get_mutable_distinguishing() { return distinguishing; }
+        void set_distinguishing(const nlohmann::json & value) { this->distinguishing = value; }
+
+        const nlohmann::json & get_elytroposis() const { return elytroposis; }
+        nlohmann::json & get_mutable_elytroposis() { return elytroposis; }
+        void set_elytroposis(const nlohmann::json & value) { this->elytroposis = value; }
+
+        const nlohmann::json & get_gentianwort() const { return gentianwort; }
+        nlohmann::json & get_mutable_gentianwort() { return gentianwort; }
+        void set_gentianwort(const nlohmann::json & value) { this->gentianwort = value; }
+
+        const nlohmann::json & get_heliosis() const { return heliosis; }
+        nlohmann::json & get_mutable_heliosis() { return heliosis; }
+        void set_heliosis(const nlohmann::json & value) { this->heliosis = value; }
+
+        const nlohmann::json & get_instrumental() const { return instrumental; }
+        nlohmann::json & get_mutable_instrumental() { return instrumental; }
+        void set_instrumental(const nlohmann::json & value) { this->instrumental = value; }
+
+        const nlohmann::json & get_introinflection() const { return introinflection; }
+        nlohmann::json & get_mutable_introinflection() { return introinflection; }
+        void set_introinflection(const nlohmann::json & value) { this->introinflection = value; }
+
+        const nlohmann::json & get_kala() const { return kala; }
+        nlohmann::json & get_mutable_kala() { return kala; }
+        void set_kala(const nlohmann::json & value) { this->kala = value; }
+
+        const nlohmann::json & get_lincolnian() const { return lincolnian; }
+        nlohmann::json & get_mutable_lincolnian() { return lincolnian; }
+        void set_lincolnian(const nlohmann::json & value) { this->lincolnian = value; }
+
+        const nlohmann::json & get_metad() const { return metad; }
+        nlohmann::json & get_mutable_metad() { return metad; }
+        void set_metad(const nlohmann::json & value) { this->metad = value; }
+
+        const nlohmann::json & get_sarcophilus() const { return sarcophilus; }
+        nlohmann::json & get_mutable_sarcophilus() { return sarcophilus; }
+        void set_sarcophilus(const nlohmann::json & value) { this->sarcophilus = value; }
+
+        const nlohmann::json & get_swingingly() const { return swingingly; }
+        nlohmann::json & get_mutable_swingingly() { return swingingly; }
+        void set_swingingly(const nlohmann::json & value) { this->swingingly = value; }
+
+        const nlohmann::json & get_unconformity() const { return unconformity; }
+        nlohmann::json & get_mutable_unconformity() { return unconformity; }
+        void set_unconformity(const nlohmann::json & value) { this->unconformity = value; }
+
+        const nlohmann::json & get_undecreed() const { return undecreed; }
+        nlohmann::json & get_mutable_undecreed() { return undecreed; }
+        void set_undecreed(const nlohmann::json & value) { this->undecreed = value; }
+
+        const nlohmann::json & get_venerable() const { return venerable; }
+        nlohmann::json & get_mutable_venerable() { return venerable; }
+        void set_venerable(const nlohmann::json & value) { this->venerable = value; }
+
+        const nlohmann::json & get_vowellessness() const { return vowellessness; }
+        nlohmann::json & get_mutable_vowellessness() { return vowellessness; }
+        void set_vowellessness(const nlohmann::json & value) { this->vowellessness = value; }
+    };
+
+    using UnstressedElement = std::variant<bool, UnstressedClass, std::string>;
+
+    using Untasked = std::variant<std::vector<nlohmann::json>, double, std::map<std::string, int64_t>>;
+
+    using Unvarying = std::variant<bool, double, std::map<std::string, int64_t>>;
+
+    using Vehemently = std::optional<std::variant<std::vector<nlohmann::json>, bool>>;
+
+    using Whitepot = std::variant<QuebrachineClass, double>;
+
+    class WrothyClass {
+        public:
+        WrothyClass() = default;
+        virtual ~WrothyClass() = default;
+
+        private:
+        nlohmann::json aeschynanthus;
+        nlohmann::json aquiferous;
+        nlohmann::json cheapener;
+        nlohmann::json enumeration;
+        nlohmann::json ephesine;
+        nlohmann::json escadrille;
+        nlohmann::json estrous;
+        nlohmann::json interestedly;
+        nlohmann::json katakinetomer;
+        nlohmann::json mortification;
+        nlohmann::json morula;
+        nlohmann::json orthosymmetrical;
+        nlohmann::json overbark;
+        nlohmann::json politist;
+        nlohmann::json qualified;
+        nlohmann::json sphenomalar;
+        nlohmann::json throatful;
+        nlohmann::json transhumance;
+        nlohmann::json triandrian;
+        nlohmann::json unbooked;
+
+        public:
+        const nlohmann::json & get_aeschynanthus() const { return aeschynanthus; }
+        nlohmann::json & get_mutable_aeschynanthus() { return aeschynanthus; }
+        void set_aeschynanthus(const nlohmann::json & value) { this->aeschynanthus = value; }
+
+        const nlohmann::json & get_aquiferous() const { return aquiferous; }
+        nlohmann::json & get_mutable_aquiferous() { return aquiferous; }
+        void set_aquiferous(const nlohmann::json & value) { this->aquiferous = value; }
+
+        const nlohmann::json & get_cheapener() const { return cheapener; }
+        nlohmann::json & get_mutable_cheapener() { return cheapener; }
+        void set_cheapener(const nlohmann::json & value) { this->cheapener = value; }
+
+        const nlohmann::json & get_enumeration() const { return enumeration; }
+        nlohmann::json & get_mutable_enumeration() { return enumeration; }
+        void set_enumeration(const nlohmann::json & value) { this->enumeration = value; }
+
+        const nlohmann::json & get_ephesine() const { return ephesine; }
+        nlohmann::json & get_mutable_ephesine() { return ephesine; }
+        void set_ephesine(const nlohmann::json & value) { this->ephesine = value; }
+
+        const nlohmann::json & get_escadrille() const { return escadrille; }
+        nlohmann::json & get_mutable_escadrille() { return escadrille; }
+        void set_escadrille(const nlohmann::json & value) { this->escadrille = value; }
+
+        const nlohmann::json & get_estrous() const { return estrous; }
+        nlohmann::json & get_mutable_estrous() { return estrous; }
+        void set_estrous(const nlohmann::json & value) { this->estrous = value; }
+
+        const nlohmann::json & get_interestedly() const { return interestedly; }
+        nlohmann::json & get_mutable_interestedly() { return interestedly; }
+        void set_interestedly(const nlohmann::json & value) { this->interestedly = value; }
+
+        const nlohmann::json & get_katakinetomer() const { return katakinetomer; }
+        nlohmann::json & get_mutable_katakinetomer() { return katakinetomer; }
+        void set_katakinetomer(const nlohmann::json & value) { this->katakinetomer = value; }
+
+        const nlohmann::json & get_mortification() const { return mortification; }
+        nlohmann::json & get_mutable_mortification() { return mortification; }
+        void set_mortification(const nlohmann::json & value) { this->mortification = value; }
+
+        const nlohmann::json & get_morula() const { return morula; }
+        nlohmann::json & get_mutable_morula() { return morula; }
+        void set_morula(const nlohmann::json & value) { this->morula = value; }
+
+        const nlohmann::json & get_orthosymmetrical() const { return orthosymmetrical; }
+        nlohmann::json & get_mutable_orthosymmetrical() { return orthosymmetrical; }
+        void set_orthosymmetrical(const nlohmann::json & value) { this->orthosymmetrical = value; }
+
+        const nlohmann::json & get_overbark() const { return overbark; }
+        nlohmann::json & get_mutable_overbark() { return overbark; }
+        void set_overbark(const nlohmann::json & value) { this->overbark = value; }
+
+        const nlohmann::json & get_politist() const { return politist; }
+        nlohmann::json & get_mutable_politist() { return politist; }
+        void set_politist(const nlohmann::json & value) { this->politist = value; }
+
+        const nlohmann::json & get_qualified() const { return qualified; }
+        nlohmann::json & get_mutable_qualified() { return qualified; }
+        void set_qualified(const nlohmann::json & value) { this->qualified = value; }
+
+        const nlohmann::json & get_sphenomalar() const { return sphenomalar; }
+        nlohmann::json & get_mutable_sphenomalar() { return sphenomalar; }
+        void set_sphenomalar(const nlohmann::json & value) { this->sphenomalar = value; }
+
+        const nlohmann::json & get_throatful() const { return throatful; }
+        nlohmann::json & get_mutable_throatful() { return throatful; }
+        void set_throatful(const nlohmann::json & value) { this->throatful = value; }
+
+        const nlohmann::json & get_transhumance() const { return transhumance; }
+        nlohmann::json & get_mutable_transhumance() { return transhumance; }
+        void set_transhumance(const nlohmann::json & value) { this->transhumance = value; }
+
+        const nlohmann::json & get_triandrian() const { return triandrian; }
+        nlohmann::json & get_mutable_triandrian() { return triandrian; }
+        void set_triandrian(const nlohmann::json & value) { this->triandrian = value; }
+
+        const nlohmann::json & get_unbooked() const { return unbooked; }
+        nlohmann::json & get_mutable_unbooked() { return unbooked; }
+        void set_unbooked(const nlohmann::json & value) { this->unbooked = value; }
+    };
+
+    using WrothyElement = std::variant<std::vector<nlohmann::json>, WrothyClass>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::vector<Protrusive> protrusive;
+        std::vector<PulpitismElement> pulpitism;
+        std::vector<PyodermiaElement> pyodermia;
+        std::vector<QuebrachineElement> quebrachine;
+        std::vector<Querier> querier;
+        std::vector<Rebarbative> rebarbative;
+        std::vector<Reimagine> reimagine;
+        Ressaut ressaut;
+        std::vector<Retrocervical> retrocervical;
+        std::vector<Revert> revert;
+        std::vector<RewriteElement> rewrite;
+        std::vector<Saccoderm> saccoderm;
+        std::vector<SantirElement> santir;
+        std::vector<Saprophilous> saprophilous;
+        std::vector<SaxtenElement> saxten;
+        std::vector<std::optional<Scatty>> scatty;
+        std::vector<Scoffer> scoffer;
+        std::vector<Scrampum> scrampum;
+        double semantic;
+        std::vector<Serpentinic> serpentinic;
+        std::vector<Shadowable> shadowable;
+        std::vector<SisteringElement> sistering;
+        std::vector<Staghunting> staghunting;
+        std::vector<Stagmometer> stagmometer;
+        std::vector<Stimulability> stimulability;
+        std::vector<Strangleable> strangleable;
+        std::vector<StrenuosityElement> strenuosity;
+        std::vector<Tabaxir> tabaxir;
+        std::vector<Talpiform> talpiform;
+        std::vector<Thwack> thwack;
+        std::vector<std::optional<double>> to;
+        std::vector<Tortricine> tortricine;
+        std::vector<TruantcyElement> truantcy;
+        std::vector<std::string> turgesce;
+        std::vector<Unbeginning> unbeginning;
+        std::vector<double> underdunged;
+        std::vector<Undesirability> undesirability;
+        std::vector<Unerasing> unerasing;
+        std::vector<Unguentarium> unguentarium;
+        std::vector<UnimpeachablyElement> unimpeachably;
+        std::vector<Unmortgaged> unmortgaged;
+        std::vector<Unobstructed> unobstructed;
+        std::vector<Unreceptivity> unreceptivity;
+        std::vector<Unsatisfactoriness> unsatisfactoriness;
+        std::vector<int64_t> unsecurity;
+        std::vector<UnstressedElement> unstressed;
+        std::vector<Untasked> untasked;
+        std::vector<Unvarying> unvarying;
+        std::vector<Vehemently> vehemently;
+        std::map<std::string, bool> warriorship;
+        std::vector<Whitepot> whitepot;
+        std::vector<WrothyElement> wrothy;
+
+        public:
+        const std::vector<Protrusive> & get_protrusive() const { return protrusive; }
+        std::vector<Protrusive> & get_mutable_protrusive() { return protrusive; }
+        void set_protrusive(const std::vector<Protrusive> & value) { this->protrusive = value; }
+
+        const std::vector<PulpitismElement> & get_pulpitism() const { return pulpitism; }
+        std::vector<PulpitismElement> & get_mutable_pulpitism() { return pulpitism; }
+        void set_pulpitism(const std::vector<PulpitismElement> & value) { this->pulpitism = value; }
+
+        const std::vector<PyodermiaElement> & get_pyodermia() const { return pyodermia; }
+        std::vector<PyodermiaElement> & get_mutable_pyodermia() { return pyodermia; }
+        void set_pyodermia(const std::vector<PyodermiaElement> & value) { this->pyodermia = value; }
+
+        const std::vector<QuebrachineElement> & get_quebrachine() const { return quebrachine; }
+        std::vector<QuebrachineElement> & get_mutable_quebrachine() { return quebrachine; }
+        void set_quebrachine(const std::vector<QuebrachineElement> & value) { this->quebrachine = value; }
+
+        const std::vector<Querier> & get_querier() const { return querier; }
+        std::vector<Querier> & get_mutable_querier() { return querier; }
+        void set_querier(const std::vector<Querier> & value) { this->querier = value; }
+
+        const std::vector<Rebarbative> & get_rebarbative() const { return rebarbative; }
+        std::vector<Rebarbative> & get_mutable_rebarbative() { return rebarbative; }
+        void set_rebarbative(const std::vector<Rebarbative> & value) { this->rebarbative = value; }
+
+        const std::vector<Reimagine> & get_reimagine() const { return reimagine; }
+        std::vector<Reimagine> & get_mutable_reimagine() { return reimagine; }
+        void set_reimagine(const std::vector<Reimagine> & value) { this->reimagine = value; }
+
+        const Ressaut & get_ressaut() const { return ressaut; }
+        Ressaut & get_mutable_ressaut() { return ressaut; }
+        void set_ressaut(const Ressaut & value) { this->ressaut = value; }
+
+        const std::vector<Retrocervical> & get_retrocervical() const { return retrocervical; }
+        std::vector<Retrocervical> & get_mutable_retrocervical() { return retrocervical; }
+        void set_retrocervical(const std::vector<Retrocervical> & value) { this->retrocervical = value; }
+
+        const std::vector<Revert> & get_revert() const { return revert; }
+        std::vector<Revert> & get_mutable_revert() { return revert; }
+        void set_revert(const std::vector<Revert> & value) { this->revert = value; }
+
+        const std::vector<RewriteElement> & get_rewrite() const { return rewrite; }
+        std::vector<RewriteElement> & get_mutable_rewrite() { return rewrite; }
+        void set_rewrite(const std::vector<RewriteElement> & value) { this->rewrite = value; }
+
+        const std::vector<Saccoderm> & get_saccoderm() const { return saccoderm; }
+        std::vector<Saccoderm> & get_mutable_saccoderm() { return saccoderm; }
+        void set_saccoderm(const std::vector<Saccoderm> & value) { this->saccoderm = value; }
+
+        const std::vector<SantirElement> & get_santir() const { return santir; }
+        std::vector<SantirElement> & get_mutable_santir() { return santir; }
+        void set_santir(const std::vector<SantirElement> & value) { this->santir = value; }
+
+        const std::vector<Saprophilous> & get_saprophilous() const { return saprophilous; }
+        std::vector<Saprophilous> & get_mutable_saprophilous() { return saprophilous; }
+        void set_saprophilous(const std::vector<Saprophilous> & value) { this->saprophilous = value; }
+
+        const std::vector<SaxtenElement> & get_saxten() const { return saxten; }
+        std::vector<SaxtenElement> & get_mutable_saxten() { return saxten; }
+        void set_saxten(const std::vector<SaxtenElement> & value) { this->saxten = value; }
+
+        const std::vector<std::optional<Scatty>> & get_scatty() const { return scatty; }
+        std::vector<std::optional<Scatty>> & get_mutable_scatty() { return scatty; }
+        void set_scatty(const std::vector<std::optional<Scatty>> & value) { this->scatty = value; }
+
+        const std::vector<Scoffer> & get_scoffer() const { return scoffer; }
+        std::vector<Scoffer> & get_mutable_scoffer() { return scoffer; }
+        void set_scoffer(const std::vector<Scoffer> & value) { this->scoffer = value; }
+
+        const std::vector<Scrampum> & get_scrampum() const { return scrampum; }
+        std::vector<Scrampum> & get_mutable_scrampum() { return scrampum; }
+        void set_scrampum(const std::vector<Scrampum> & value) { this->scrampum = value; }
+
+        const double & get_semantic() const { return semantic; }
+        double & get_mutable_semantic() { return semantic; }
+        void set_semantic(const double & value) { this->semantic = value; }
+
+        const std::vector<Serpentinic> & get_serpentinic() const { return serpentinic; }
+        std::vector<Serpentinic> & get_mutable_serpentinic() { return serpentinic; }
+        void set_serpentinic(const std::vector<Serpentinic> & value) { this->serpentinic = value; }
+
+        const std::vector<Shadowable> & get_shadowable() const { return shadowable; }
+        std::vector<Shadowable> & get_mutable_shadowable() { return shadowable; }
+        void set_shadowable(const std::vector<Shadowable> & value) { this->shadowable = value; }
+
+        const std::vector<SisteringElement> & get_sistering() const { return sistering; }
+        std::vector<SisteringElement> & get_mutable_sistering() { return sistering; }
+        void set_sistering(const std::vector<SisteringElement> & value) { this->sistering = value; }
+
+        const std::vector<Staghunting> & get_staghunting() const { return staghunting; }
+        std::vector<Staghunting> & get_mutable_staghunting() { return staghunting; }
+        void set_staghunting(const std::vector<Staghunting> & value) { this->staghunting = value; }
+
+        const std::vector<Stagmometer> & get_stagmometer() const { return stagmometer; }
+        std::vector<Stagmometer> & get_mutable_stagmometer() { return stagmometer; }
+        void set_stagmometer(const std::vector<Stagmometer> & value) { this->stagmometer = value; }
+
+        const std::vector<Stimulability> & get_stimulability() const { return stimulability; }
+        std::vector<Stimulability> & get_mutable_stimulability() { return stimulability; }
+        void set_stimulability(const std::vector<Stimulability> & value) { this->stimulability = value; }
+
+        const std::vector<Strangleable> & get_strangleable() const { return strangleable; }
+        std::vector<Strangleable> & get_mutable_strangleable() { return strangleable; }
+        void set_strangleable(const std::vector<Strangleable> & value) { this->strangleable = value; }
+
+        const std::vector<StrenuosityElement> & get_strenuosity() const { return strenuosity; }
+        std::vector<StrenuosityElement> & get_mutable_strenuosity() { return strenuosity; }
+        void set_strenuosity(const std::vector<StrenuosityElement> & value) { this->strenuosity = value; }
+
+        const std::vector<Tabaxir> & get_tabaxir() const { return tabaxir; }
+        std::vector<Tabaxir> & get_mutable_tabaxir() { return tabaxir; }
+        void set_tabaxir(const std::vector<Tabaxir> & value) { this->tabaxir = value; }
+
+        const std::vector<Talpiform> & get_talpiform() const { return talpiform; }
+        std::vector<Talpiform> & get_mutable_talpiform() { return talpiform; }
+        void set_talpiform(const std::vector<Talpiform> & value) { this->talpiform = value; }
+
+        const std::vector<Thwack> & get_thwack() const { return thwack; }
+        std::vector<Thwack> & get_mutable_thwack() { return thwack; }
+        void set_thwack(const std::vector<Thwack> & value) { this->thwack = value; }
+
+        const std::vector<std::optional<double>> & get_to() const { return to; }
+        std::vector<std::optional<double>> & get_mutable_to() { return to; }
+        void set_to(const std::vector<std::optional<double>> & value) { this->to = value; }
+
+        const std::vector<Tortricine> & get_tortricine() const { return tortricine; }
+        std::vector<Tortricine> & get_mutable_tortricine() { return tortricine; }
+        void set_tortricine(const std::vector<Tortricine> & value) { this->tortricine = value; }
+
+        const std::vector<TruantcyElement> & get_truantcy() const { return truantcy; }
+        std::vector<TruantcyElement> & get_mutable_truantcy() { return truantcy; }
+        void set_truantcy(const std::vector<TruantcyElement> & value) { this->truantcy = value; }
+
+        const std::vector<std::string> & get_turgesce() const { return turgesce; }
+        std::vector<std::string> & get_mutable_turgesce() { return turgesce; }
+        void set_turgesce(const std::vector<std::string> & value) { this->turgesce = value; }
+
+        const std::vector<Unbeginning> & get_unbeginning() const { return unbeginning; }
+        std::vector<Unbeginning> & get_mutable_unbeginning() { return unbeginning; }
+        void set_unbeginning(const std::vector<Unbeginning> & value) { this->unbeginning = value; }
+
+        const std::vector<double> & get_underdunged() const { return underdunged; }
+        std::vector<double> & get_mutable_underdunged() { return underdunged; }
+        void set_underdunged(const std::vector<double> & value) { this->underdunged = value; }
+
+        const std::vector<Undesirability> & get_undesirability() const { return undesirability; }
+        std::vector<Undesirability> & get_mutable_undesirability() { return undesirability; }
+        void set_undesirability(const std::vector<Undesirability> & value) { this->undesirability = value; }
+
+        const std::vector<Unerasing> & get_unerasing() const { return unerasing; }
+        std::vector<Unerasing> & get_mutable_unerasing() { return unerasing; }
+        void set_unerasing(const std::vector<Unerasing> & value) { this->unerasing = value; }
+
+        const std::vector<Unguentarium> & get_unguentarium() const { return unguentarium; }
+        std::vector<Unguentarium> & get_mutable_unguentarium() { return unguentarium; }
+        void set_unguentarium(const std::vector<Unguentarium> & value) { this->unguentarium = value; }
+
+        const std::vector<UnimpeachablyElement> & get_unimpeachably() const { return unimpeachably; }
+        std::vector<UnimpeachablyElement> & get_mutable_unimpeachably() { return unimpeachably; }
+        void set_unimpeachably(const std::vector<UnimpeachablyElement> & value) { this->unimpeachably = value; }
+
+        const std::vector<Unmortgaged> & get_unmortgaged() const { return unmortgaged; }
+        std::vector<Unmortgaged> & get_mutable_unmortgaged() { return unmortgaged; }
+        void set_unmortgaged(const std::vector<Unmortgaged> & value) { this->unmortgaged = value; }
+
+        const std::vector<Unobstructed> & get_unobstructed() const { return unobstructed; }
+        std::vector<Unobstructed> & get_mutable_unobstructed() { return unobstructed; }
+        void set_unobstructed(const std::vector<Unobstructed> & value) { this->unobstructed = value; }
+
+        const std::vector<Unreceptivity> & get_unreceptivity() const { return unreceptivity; }
+        std::vector<Unreceptivity> & get_mutable_unreceptivity() { return unreceptivity; }
+        void set_unreceptivity(const std::vector<Unreceptivity> & value) { this->unreceptivity = value; }
+
+        const std::vector<Unsatisfactoriness> & get_unsatisfactoriness() const { return unsatisfactoriness; }
+        std::vector<Unsatisfactoriness> & get_mutable_unsatisfactoriness() { return unsatisfactoriness; }
+        void set_unsatisfactoriness(const std::vector<Unsatisfactoriness> & value) { this->unsatisfactoriness = value; }
+
+        const std::vector<int64_t> & get_unsecurity() const { return unsecurity; }
+        std::vector<int64_t> & get_mutable_unsecurity() { return unsecurity; }
+        void set_unsecurity(const std::vector<int64_t> & value) { this->unsecurity = value; }
+
+        const std::vector<UnstressedElement> & get_unstressed() const { return unstressed; }
+        std::vector<UnstressedElement> & get_mutable_unstressed() { return unstressed; }
+        void set_unstressed(const std::vector<UnstressedElement> & value) { this->unstressed = value; }
+
+        const std::vector<Untasked> & get_untasked() const { return untasked; }
+        std::vector<Untasked> & get_mutable_untasked() { return untasked; }
+        void set_untasked(const std::vector<Untasked> & value) { this->untasked = value; }
+
+        const std::vector<Unvarying> & get_unvarying() const { return unvarying; }
+        std::vector<Unvarying> & get_mutable_unvarying() { return unvarying; }
+        void set_unvarying(const std::vector<Unvarying> & value) { this->unvarying = value; }
+
+        const std::vector<Vehemently> & get_vehemently() const { return vehemently; }
+        std::vector<Vehemently> & get_mutable_vehemently() { return vehemently; }
+        void set_vehemently(const std::vector<Vehemently> & value) { this->vehemently = value; }
+
+        const std::map<std::string, bool> & get_warriorship() const { return warriorship; }
+        std::map<std::string, bool> & get_mutable_warriorship() { return warriorship; }
+        void set_warriorship(const std::map<std::string, bool> & value) { this->warriorship = value; }
+
+        const std::vector<Whitepot> & get_whitepot() const { return whitepot; }
+        std::vector<Whitepot> & get_mutable_whitepot() { return whitepot; }
+        void set_whitepot(const std::vector<Whitepot> & value) { this->whitepot = value; }
+
+        const std::vector<WrothyElement> & get_wrothy() const { return wrothy; }
+        std::vector<WrothyElement> & get_mutable_wrothy() { return wrothy; }
+        void set_wrothy(const std::vector<WrothyElement> & value) { this->wrothy = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, PulpitismClass & x);
+void to_json(json & j, const PulpitismClass & x);
+
+void from_json(const json & j, PyodermiaClass & x);
+void to_json(json & j, const PyodermiaClass & x);
+
+void from_json(const json & j, QuebrachineClass & x);
+void to_json(json & j, const QuebrachineClass & x);
+
+void from_json(const json & j, Reimagine & x);
+void to_json(json & j, const Reimagine & x);
+
+void from_json(const json & j, Ressaut & x);
+void to_json(json & j, const Ressaut & x);
+
+void from_json(const json & j, RewriteClass & x);
+void to_json(json & j, const RewriteClass & x);
+
+void from_json(const json & j, SantirClass & x);
+void to_json(json & j, const SantirClass & x);
+
+void from_json(const json & j, SaxtenClass & x);
+void to_json(json & j, const SaxtenClass & x);
+
+void from_json(const json & j, Scatty & x);
+void to_json(json & j, const Scatty & x);
+
+void from_json(const json & j, SisteringClass & x);
+void to_json(json & j, const SisteringClass & x);
+
+void from_json(const json & j, Staghunting & x);
+void to_json(json & j, const Staghunting & x);
+
+void from_json(const json & j, StrenuosityClass & x);
+void to_json(json & j, const StrenuosityClass & x);
+
+void from_json(const json & j, TruantcyClass & x);
+void to_json(json & j, const TruantcyClass & x);
+
+void from_json(const json & j, UnimpeachablyClass & x);
+void to_json(json & j, const UnimpeachablyClass & x);
+
+void from_json(const json & j, UnstressedClass & x);
+void to_json(json & j, const UnstressedClass & x);
+
+void from_json(const json & j, WrothyClass & x);
+void to_json(json & j, const WrothyClass & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::PyodermiaClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::PyodermiaClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::QuebrachineClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, std::string>> {
+    static void from_json(const json & j, std::variant<bool, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::RewriteClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SantirClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::SantirClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::SantirClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SaxtenClass, std::string>> {
+    static void from_json(const json & j, std::variant<quicktype::SaxtenClass, std::string> & x);
+    static void to_json(json & j, const std::variant<quicktype::SaxtenClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::StrenuosityClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double>> {
+    static void from_json(const json & j, std::variant<bool, double> & x);
+    static void to_json(json & j, const std::variant<bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::QuebrachineClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::QuebrachineClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::QuebrachineClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass, double> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>> {
+    static void from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::TruantcyClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::TruantcyClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::TruantcyClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::UnimpeachablyClass> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::UnimpeachablyClass> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>> {
+    static void from_json(const json & j, std::variant<quicktype::QuebrachineClass, int64_t> & x);
+    static void to_json(json & j, const std::variant<quicktype::QuebrachineClass, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, int64_t, std::string>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, int64_t, std::string> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, int64_t, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>> {
+    static void from_json(const json & j, std::variant<std::vector<int64_t>, bool, int64_t> & x);
+    static void to_json(json & j, const std::variant<std::vector<int64_t>, bool, int64_t> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>> {
+    static void from_json(const json & j, std::variant<bool, quicktype::UnstressedClass, std::string> & x);
+    static void to_json(json & j, const std::variant<bool, quicktype::UnstressedClass, std::string> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>> {
+    static void from_json(const json & j, std::variant<bool, double, std::map<std::string, int64_t>> & x);
+    static void to_json(json & j, const std::variant<bool, double, std::map<std::string, int64_t>> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, bool>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, bool> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, bool> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>> {
+    static void from_json(const json & j, std::variant<std::vector<json>, quicktype::WrothyClass> & x);
+    static void to_json(json & j, const std::variant<std::vector<json>, quicktype::WrothyClass> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, PulpitismClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_abnet(get_untyped(j, "abnet"));
+        x.set_buckhorn(get_untyped(j, "buckhorn"));
+        x.set_calciform(get_untyped(j, "calciform"));
+        x.set_chelophore(get_untyped(j, "chelophore"));
+        x.set_cogitation(get_untyped(j, "cogitation"));
+        x.set_decreeable(get_untyped(j, "decreeable"));
+        x.set_despicable(get_untyped(j, "despicable"));
+        x.set_isodiazo(get_untyped(j, "isodiazo"));
+        x.set_jadedly(get_untyped(j, "jadedly"));
+        x.set_leptochlorite(get_untyped(j, "leptochlorite"));
+        x.set_nursling(get_untyped(j, "nursling"));
+        x.set_palamedean(get_untyped(j, "palamedean"));
+        x.set_photoheliograph(get_untyped(j, "photoheliograph"));
+        x.set_pipewood(get_untyped(j, "pipewood"));
+        x.set_roberd(get_untyped(j, "roberd"));
+        x.set_statable(get_untyped(j, "statable"));
+        x.set_superassume(get_untyped(j, "superassume"));
+        x.set_syllabe(get_untyped(j, "syllabe"));
+        x.set_toughhead(get_untyped(j, "toughhead"));
+        x.set_underburn(get_untyped(j, "underburn"));
+    }
+
+    inline void to_json(json & j, const PulpitismClass & x) {
+        j = json::object();
+        j["abnet"] = x.get_abnet();
+        j["buckhorn"] = x.get_buckhorn();
+        j["calciform"] = x.get_calciform();
+        j["chelophore"] = x.get_chelophore();
+        j["cogitation"] = x.get_cogitation();
+        j["decreeable"] = x.get_decreeable();
+        j["despicable"] = x.get_despicable();
+        j["isodiazo"] = x.get_isodiazo();
+        j["jadedly"] = x.get_jadedly();
+        j["leptochlorite"] = x.get_leptochlorite();
+        j["nursling"] = x.get_nursling();
+        j["palamedean"] = x.get_palamedean();
+        j["photoheliograph"] = x.get_photoheliograph();
+        j["pipewood"] = x.get_pipewood();
+        j["roberd"] = x.get_roberd();
+        j["statable"] = x.get_statable();
+        j["superassume"] = x.get_superassume();
+        j["syllabe"] = x.get_syllabe();
+        j["toughhead"] = x.get_toughhead();
+        j["underburn"] = x.get_underburn();
+    }
+
+    inline void from_json(const json & j, PyodermiaClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_aphoristically(get_untyped(j, "aphoristically"));
+        x.set_apophyllous(get_untyped(j, "apophyllous"));
+        x.set_cognize(get_untyped(j, "cognize"));
+        x.set_dermonosology(get_untyped(j, "dermonosology"));
+        x.set_gyppo(get_untyped(j, "Gyppo"));
+        x.set_ither(get_untyped(j, "ither"));
+        x.set_juglandaceous(get_untyped(j, "juglandaceous"));
+        x.set_litho(get_untyped(j, "litho"));
+        x.set_macropterous(get_untyped(j, "macropterous"));
+        x.set_photographer(get_untyped(j, "photographer"));
+        x.set_romancing(get_untyped(j, "romancing"));
+        x.set_rumness(get_untyped(j, "rumness"));
+        x.set_somniloquist(get_untyped(j, "somniloquist"));
+        x.set_stressfully(get_untyped(j, "stressfully"));
+        x.set_tactically(get_untyped(j, "tactically"));
+        x.set_tracheophony(get_untyped(j, "tracheophony"));
+        x.set_unappositely(get_untyped(j, "unappositely"));
+        x.set_unclothedly(get_untyped(j, "unclothedly"));
+        x.set_unimplied(get_untyped(j, "unimplied"));
+        x.set_unsyncopated(get_untyped(j, "unsyncopated"));
+    }
+
+    inline void to_json(json & j, const PyodermiaClass & x) {
+        j = json::object();
+        j["aphoristically"] = x.get_aphoristically();
+        j["apophyllous"] = x.get_apophyllous();
+        j["cognize"] = x.get_cognize();
+        j["dermonosology"] = x.get_dermonosology();
+        j["Gyppo"] = x.get_gyppo();
+        j["ither"] = x.get_ither();
+        j["juglandaceous"] = x.get_juglandaceous();
+        j["litho"] = x.get_litho();
+        j["macropterous"] = x.get_macropterous();
+        j["photographer"] = x.get_photographer();
+        j["romancing"] = x.get_romancing();
+        j["rumness"] = x.get_rumness();
+        j["somniloquist"] = x.get_somniloquist();
+        j["stressfully"] = x.get_stressfully();
+        j["tactically"] = x.get_tactically();
+        j["tracheophony"] = x.get_tracheophony();
+        j["unappositely"] = x.get_unappositely();
+        j["unclothedly"] = x.get_unclothedly();
+        j["unimplied"] = x.get_unimplied();
+        j["unsyncopated"] = x.get_unsyncopated();
+    }
+
+    inline void from_json(const json & j, QuebrachineClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_catharticalness(j.at("catharticalness").get<double>());
+        x.set_chirotherium(j.at("Chirotherium").get<int64_t>());
+        x.set_disdiapason(j.at("disdiapason").get<std::string>());
+        x.set_homocerc(j.at("homocerc").get<bool>());
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+    }
+
+    inline void to_json(json & j, const QuebrachineClass & x) {
+        j = json::object();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["homocerc"] = x.get_homocerc();
+        j["nonbookish"] = x.get_nonbookish();
+    }
+
+    inline void from_json(const json & j, Reimagine& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_adducible(get_untyped(j, "adducible"));
+        x.set_anabolin(get_untyped(j, "anabolin"));
+        x.set_brainy(get_untyped(j, "brainy"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chrysamine(get_untyped(j, "chrysamine"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_fluxweed(get_untyped(j, "fluxweed"));
+        x.set_glaucine(get_untyped(j, "glaucine"));
+        x.set_grobianism(get_untyped(j, "grobianism"));
+        x.set_hermo(get_untyped(j, "Hermo"));
+        x.set_hieroglyphist(get_untyped(j, "hieroglyphist"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_icteroid(get_untyped(j, "icteroid"));
+        x.set_immortal(get_untyped(j, "immortal"));
+        x.set_impetulant(get_untyped(j, "impetulant"));
+        x.set_irrigate(get_untyped(j, "irrigate"));
+        x.set_myxedema(get_untyped(j, "myxedema"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_onyx(get_untyped(j, "onyx"));
+        x.set_repasser(get_untyped(j, "repasser"));
+        x.set_septomarginal(get_untyped(j, "septomarginal"));
+        x.set_subdie(get_untyped(j, "subdie"));
+        x.set_tibiometatarsal(get_untyped(j, "tibiometatarsal"));
+        x.set_waltzlike(get_untyped(j, "waltzlike"));
+    }
+
+    inline void to_json(json & j, const Reimagine & x) {
+        j = json::object();
+        j["adducible"] = x.get_adducible();
+        j["anabolin"] = x.get_anabolin();
+        j["brainy"] = x.get_brainy();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chrysamine"] = x.get_chrysamine();
+        j["disdiapason"] = x.get_disdiapason();
+        j["fluxweed"] = x.get_fluxweed();
+        j["glaucine"] = x.get_glaucine();
+        j["grobianism"] = x.get_grobianism();
+        j["Hermo"] = x.get_hermo();
+        j["hieroglyphist"] = x.get_hieroglyphist();
+        j["homocerc"] = x.get_homocerc();
+        j["icteroid"] = x.get_icteroid();
+        j["immortal"] = x.get_immortal();
+        j["impetulant"] = x.get_impetulant();
+        j["irrigate"] = x.get_irrigate();
+        j["myxedema"] = x.get_myxedema();
+        j["nonbookish"] = x.get_nonbookish();
+        j["onyx"] = x.get_onyx();
+        j["repasser"] = x.get_repasser();
+        j["septomarginal"] = x.get_septomarginal();
+        j["subdie"] = x.get_subdie();
+        j["tibiometatarsal"] = x.get_tibiometatarsal();
+        j["waltzlike"] = x.get_waltzlike();
+    }
+
+    inline void from_json(const json & j, Ressaut& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_apperceptive(j.at("apperceptive").get<std::string>());
+        x.set_cuttoo(j.at("cuttoo").get<std::string>());
+        x.set_douser(j.at("douser").get<std::string>());
+        x.set_drinkproof(j.at("drinkproof").get<std::string>());
+        x.set_forementioned(j.at("forementioned").get<std::string>());
+        x.set_freesia(j.at("Freesia").get<std::string>());
+        x.set_genevieve(j.at("Genevieve").get<std::string>());
+        x.set_hyperdiabolical(j.at("hyperdiabolical").get<std::string>());
+        x.set_hypocone(j.at("hypocone").get<std::string>());
+        x.set_irreverentially(j.at("irreverentially").get<std::string>());
+        x.set_jumart(j.at("jumart").get<std::string>());
+        x.set_mimosaceae(j.at("Mimosaceae").get<std::string>());
+        x.set_mollicrush(j.at("mollicrush").get<std::string>());
+        x.set_nedder(j.at("nedder").get<std::string>());
+        x.set_retinasphalt(j.at("retinasphalt").get<std::string>());
+        x.set_sough(j.at("sough").get<std::string>());
+        x.set_steading(j.at("steading").get<std::string>());
+        x.set_theopaschitism(j.at("Theopaschitism").get<std::string>());
+        x.set_undurableness(j.at("undurableness").get<std::string>());
+        x.set_unmingleable(j.at("unmingleable").get<std::string>());
+    }
+
+    inline void to_json(json & j, const Ressaut & x) {
+        j = json::object();
+        j["apperceptive"] = x.get_apperceptive();
+        j["cuttoo"] = x.get_cuttoo();
+        j["douser"] = x.get_douser();
+        j["drinkproof"] = x.get_drinkproof();
+        j["forementioned"] = x.get_forementioned();
+        j["Freesia"] = x.get_freesia();
+        j["Genevieve"] = x.get_genevieve();
+        j["hyperdiabolical"] = x.get_hyperdiabolical();
+        j["hypocone"] = x.get_hypocone();
+        j["irreverentially"] = x.get_irreverentially();
+        j["jumart"] = x.get_jumart();
+        j["Mimosaceae"] = x.get_mimosaceae();
+        j["mollicrush"] = x.get_mollicrush();
+        j["nedder"] = x.get_nedder();
+        j["retinasphalt"] = x.get_retinasphalt();
+        j["sough"] = x.get_sough();
+        j["steading"] = x.get_steading();
+        j["Theopaschitism"] = x.get_theopaschitism();
+        j["undurableness"] = x.get_undurableness();
+        j["unmingleable"] = x.get_unmingleable();
+    }
+
+    inline void from_json(const json & j, RewriteClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_accountancy(get_untyped(j, "accountancy"));
+        x.set_cacotrophic(get_untyped(j, "cacotrophic"));
+        x.set_contest(get_untyped(j, "contest"));
+        x.set_couthily(get_untyped(j, "couthily"));
+        x.set_falculate(get_untyped(j, "falculate"));
+        x.set_foreseize(get_untyped(j, "foreseize"));
+        x.set_hyades(get_untyped(j, "Hyades"));
+        x.set_lemnad(get_untyped(j, "lemnad"));
+        x.set_monotheistically(get_untyped(j, "monotheistically"));
+        x.set_nonflying(get_untyped(j, "nonflying"));
+        x.set_ptenoglossa(get_untyped(j, "Ptenoglossa"));
+        x.set_repatch(get_untyped(j, "repatch"));
+        x.set_rodman(get_untyped(j, "rodman"));
+        x.set_strung(get_untyped(j, "strung"));
+        x.set_titmal(get_untyped(j, "titmal"));
+        x.set_twalpennyworth(get_untyped(j, "twalpennyworth"));
+        x.set_unblamable(get_untyped(j, "unblamable"));
+        x.set_vertical(get_untyped(j, "vertical"));
+        x.set_whiggification(get_untyped(j, "Whiggification"));
+        x.set_yardman(get_untyped(j, "yardman"));
+    }
+
+    inline void to_json(json & j, const RewriteClass & x) {
+        j = json::object();
+        j["accountancy"] = x.get_accountancy();
+        j["cacotrophic"] = x.get_cacotrophic();
+        j["contest"] = x.get_contest();
+        j["couthily"] = x.get_couthily();
+        j["falculate"] = x.get_falculate();
+        j["foreseize"] = x.get_foreseize();
+        j["Hyades"] = x.get_hyades();
+        j["lemnad"] = x.get_lemnad();
+        j["monotheistically"] = x.get_monotheistically();
+        j["nonflying"] = x.get_nonflying();
+        j["Ptenoglossa"] = x.get_ptenoglossa();
+        j["repatch"] = x.get_repatch();
+        j["rodman"] = x.get_rodman();
+        j["strung"] = x.get_strung();
+        j["titmal"] = x.get_titmal();
+        j["twalpennyworth"] = x.get_twalpennyworth();
+        j["unblamable"] = x.get_unblamable();
+        j["vertical"] = x.get_vertical();
+        j["Whiggification"] = x.get_whiggification();
+        j["yardman"] = x.get_yardman();
+    }
+
+    inline void from_json(const json & j, SantirClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_admiredly(get_untyped(j, "admiredly"));
+        x.set_demicaponier(get_untyped(j, "demicaponier"));
+        x.set_epitympanic(get_untyped(j, "epitympanic"));
+        x.set_investitor(get_untyped(j, "investitor"));
+        x.set_lupiform(get_untyped(j, "lupiform"));
+        x.set_monoflagellate(get_untyped(j, "monoflagellate"));
+        x.set_paleoethnic(get_untyped(j, "paleoethnic"));
+        x.set_prediscountable(get_untyped(j, "prediscountable"));
+        x.set_rhetoricals(get_untyped(j, "rhetoricals"));
+        x.set_roomth(get_untyped(j, "roomth"));
+        x.set_saccharose(get_untyped(j, "saccharose"));
+        x.set_septonasal(get_untyped(j, "septonasal"));
+        x.set_serpenticide(get_untyped(j, "serpenticide"));
+        x.set_setarious(get_untyped(j, "setarious"));
+        x.set_spaework(get_untyped(j, "spaework"));
+        x.set_stylite(get_untyped(j, "stylite"));
+        x.set_suessiones(get_untyped(j, "Suessiones"));
+        x.set_timelily(get_untyped(j, "timelily"));
+        x.set_unprofaned(get_untyped(j, "unprofaned"));
+        x.set_vorticular(get_untyped(j, "vorticular"));
+    }
+
+    inline void to_json(json & j, const SantirClass & x) {
+        j = json::object();
+        j["admiredly"] = x.get_admiredly();
+        j["demicaponier"] = x.get_demicaponier();
+        j["epitympanic"] = x.get_epitympanic();
+        j["investitor"] = x.get_investitor();
+        j["lupiform"] = x.get_lupiform();
+        j["monoflagellate"] = x.get_monoflagellate();
+        j["paleoethnic"] = x.get_paleoethnic();
+        j["prediscountable"] = x.get_prediscountable();
+        j["rhetoricals"] = x.get_rhetoricals();
+        j["roomth"] = x.get_roomth();
+        j["saccharose"] = x.get_saccharose();
+        j["septonasal"] = x.get_septonasal();
+        j["serpenticide"] = x.get_serpenticide();
+        j["setarious"] = x.get_setarious();
+        j["spaework"] = x.get_spaework();
+        j["stylite"] = x.get_stylite();
+        j["Suessiones"] = x.get_suessiones();
+        j["timelily"] = x.get_timelily();
+        j["unprofaned"] = x.get_unprofaned();
+        j["vorticular"] = x.get_vorticular();
+    }
+
+    inline void from_json(const json & j, SaxtenClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_algarrobilla(get_untyped(j, "algarrobilla"));
+        x.set_bowgrace(get_untyped(j, "bowgrace"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_centaurid(get_untyped(j, "Centaurid"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_flix(get_untyped(j, "flix"));
+        x.set_germanely(get_untyped(j, "germanely"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_inhume(get_untyped(j, "inhume"));
+        x.set_lepidote(get_untyped(j, "lepidote"));
+        x.set_megalochirous(get_untyped(j, "megalochirous"));
+        x.set_ninepenny(get_untyped(j, "ninepenny"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_nondeist(get_untyped(j, "nondeist"));
+        x.set_nymphaeaceous(get_untyped(j, "nymphaeaceous"));
+        x.set_parietofrontal(get_untyped(j, "parietofrontal"));
+        x.set_sancyite(get_untyped(j, "sancyite"));
+        x.set_subjectivist(get_untyped(j, "subjectivist"));
+        x.set_tibiad(get_untyped(j, "tibiad"));
+        x.set_transonic(get_untyped(j, "transonic"));
+        x.set_tripetalous(get_untyped(j, "tripetalous"));
+        x.set_trunchman(get_untyped(j, "trunchman"));
+        x.set_urger(get_untyped(j, "urger"));
+        x.set_withdrawnness(get_untyped(j, "withdrawnness"));
+    }
+
+    inline void to_json(json & j, const SaxtenClass & x) {
+        j = json::object();
+        j["algarrobilla"] = x.get_algarrobilla();
+        j["bowgrace"] = x.get_bowgrace();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Centaurid"] = x.get_centaurid();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["flix"] = x.get_flix();
+        j["germanely"] = x.get_germanely();
+        j["homocerc"] = x.get_homocerc();
+        j["inhume"] = x.get_inhume();
+        j["lepidote"] = x.get_lepidote();
+        j["megalochirous"] = x.get_megalochirous();
+        j["ninepenny"] = x.get_ninepenny();
+        j["nonbookish"] = x.get_nonbookish();
+        j["nondeist"] = x.get_nondeist();
+        j["nymphaeaceous"] = x.get_nymphaeaceous();
+        j["parietofrontal"] = x.get_parietofrontal();
+        j["sancyite"] = x.get_sancyite();
+        j["subjectivist"] = x.get_subjectivist();
+        j["tibiad"] = x.get_tibiad();
+        j["transonic"] = x.get_transonic();
+        j["tripetalous"] = x.get_tripetalous();
+        j["trunchman"] = x.get_trunchman();
+        j["urger"] = x.get_urger();
+        j["withdrawnness"] = x.get_withdrawnness();
+    }
+
+    inline void from_json(const json & j, Scatty& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_aeriferous(get_untyped(j, "aeriferous"));
+        x.set_antical(get_untyped(j, "antical"));
+        x.set_antighostism(get_untyped(j, "antighostism"));
+        x.set_arcanum(get_untyped(j, "arcanum"));
+        x.set_autotrophy(get_untyped(j, "autotrophy"));
+        x.set_baronial(get_untyped(j, "baronial"));
+        x.set_caffeine(get_untyped(j, "caffeine"));
+        x.set_gorgoniacean(get_untyped(j, "gorgoniacean"));
+        x.set_heroical(get_untyped(j, "heroical"));
+        x.set_hydropical(get_untyped(j, "hydropical"));
+        x.set_mechanology(get_untyped(j, "mechanology"));
+        x.set_musicopoetic(get_untyped(j, "musicopoetic"));
+        x.set_officiality(get_untyped(j, "officiality"));
+        x.set_oftentimes(get_untyped(j, "oftentimes"));
+        x.set_ophthalmotonometer(get_untyped(j, "ophthalmotonometer"));
+        x.set_reflectively(get_untyped(j, "reflectively"));
+        x.set_springer(get_untyped(j, "springer"));
+        x.set_tabasco(get_untyped(j, "Tabasco"));
+        x.set_teleianthous(get_untyped(j, "teleianthous"));
+        x.set_uncombated(get_untyped(j, "uncombated"));
+    }
+
+    inline void to_json(json & j, const Scatty & x) {
+        j = json::object();
+        j["aeriferous"] = x.get_aeriferous();
+        j["antical"] = x.get_antical();
+        j["antighostism"] = x.get_antighostism();
+        j["arcanum"] = x.get_arcanum();
+        j["autotrophy"] = x.get_autotrophy();
+        j["baronial"] = x.get_baronial();
+        j["caffeine"] = x.get_caffeine();
+        j["gorgoniacean"] = x.get_gorgoniacean();
+        j["heroical"] = x.get_heroical();
+        j["hydropical"] = x.get_hydropical();
+        j["mechanology"] = x.get_mechanology();
+        j["musicopoetic"] = x.get_musicopoetic();
+        j["officiality"] = x.get_officiality();
+        j["oftentimes"] = x.get_oftentimes();
+        j["ophthalmotonometer"] = x.get_ophthalmotonometer();
+        j["reflectively"] = x.get_reflectively();
+        j["springer"] = x.get_springer();
+        j["Tabasco"] = x.get_tabasco();
+        j["teleianthous"] = x.get_teleianthous();
+        j["uncombated"] = x.get_uncombated();
+    }
+
+    inline void from_json(const json & j, SisteringClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_amphicarpic(get_untyped(j, "amphicarpic"));
+        x.set_chianti(get_untyped(j, "Chianti"));
+        x.set_frigorific(get_untyped(j, "frigorific"));
+        x.set_haplomi(get_untyped(j, "Haplomi"));
+        x.set_hyperkinesis(get_untyped(j, "hyperkinesis"));
+        x.set_laudable(get_untyped(j, "laudable"));
+        x.set_madwoman(get_untyped(j, "madwoman"));
+        x.set_maimedly(get_untyped(j, "maimedly"));
+        x.set_micropterygidae(get_untyped(j, "Micropterygidae"));
+        x.set_microrhabdus(get_untyped(j, "microrhabdus"));
+        x.set_nondense(get_untyped(j, "nondense"));
+        x.set_phlebemphraxis(get_untyped(j, "phlebemphraxis"));
+        x.set_redsear(get_untyped(j, "redsear"));
+        x.set_schismatical(get_untyped(j, "schismatical"));
+        x.set_tartryl(get_untyped(j, "tartryl"));
+        x.set_unabhorred(get_untyped(j, "unabhorred"));
+        x.set_undeliberateness(get_untyped(j, "undeliberateness"));
+        x.set_unmixable(get_untyped(j, "unmixable"));
+        x.set_untruckling(get_untyped(j, "untruckling"));
+        x.set_vineal(get_untyped(j, "vineal"));
+    }
+
+    inline void to_json(json & j, const SisteringClass & x) {
+        j = json::object();
+        j["amphicarpic"] = x.get_amphicarpic();
+        j["Chianti"] = x.get_chianti();
+        j["frigorific"] = x.get_frigorific();
+        j["Haplomi"] = x.get_haplomi();
+        j["hyperkinesis"] = x.get_hyperkinesis();
+        j["laudable"] = x.get_laudable();
+        j["madwoman"] = x.get_madwoman();
+        j["maimedly"] = x.get_maimedly();
+        j["Micropterygidae"] = x.get_micropterygidae();
+        j["microrhabdus"] = x.get_microrhabdus();
+        j["nondense"] = x.get_nondense();
+        j["phlebemphraxis"] = x.get_phlebemphraxis();
+        j["redsear"] = x.get_redsear();
+        j["schismatical"] = x.get_schismatical();
+        j["tartryl"] = x.get_tartryl();
+        j["unabhorred"] = x.get_unabhorred();
+        j["undeliberateness"] = x.get_undeliberateness();
+        j["unmixable"] = x.get_unmixable();
+        j["untruckling"] = x.get_untruckling();
+        j["vineal"] = x.get_vineal();
+    }
+
+    inline void from_json(const json & j, Staghunting& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_calorimetric(get_stack_optional<int64_t>(j, "calorimetric"));
+        x.set_canid(get_stack_optional<int64_t>(j, "canid"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ditriglyphic(get_stack_optional<int64_t>(j, "ditriglyphic"));
+        x.set_floriferousness(get_stack_optional<int64_t>(j, "floriferousness"));
+        x.set_gamelike(get_stack_optional<int64_t>(j, "gamelike"));
+        x.set_grig(get_stack_optional<int64_t>(j, "grig"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_interloan(get_stack_optional<int64_t>(j, "interloan"));
+        x.set_lithotomy(get_stack_optional<int64_t>(j, "lithotomy"));
+        x.set_loric(get_stack_optional<int64_t>(j, "loric"));
+        x.set_membranocoriaceous(get_stack_optional<int64_t>(j, "membranocoriaceous"));
+        x.set_membranogenic(get_stack_optional<int64_t>(j, "membranogenic"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_overtrump(get_stack_optional<int64_t>(j, "overtrump"));
+        x.set_scotino(get_stack_optional<int64_t>(j, "scotino"));
+        x.set_seasonable(get_stack_optional<int64_t>(j, "seasonable"));
+        x.set_sephen(get_stack_optional<int64_t>(j, "sephen"));
+        x.set_stigmarioid(get_stack_optional<int64_t>(j, "stigmarioid"));
+        x.set_tired(get_stack_optional<int64_t>(j, "tired"));
+        x.set_trifid(get_stack_optional<int64_t>(j, "trifid"));
+        x.set_undefeatedly(get_stack_optional<int64_t>(j, "undefeatedly"));
+        x.set_ungirlish(get_stack_optional<int64_t>(j, "ungirlish"));
+    }
+
+    inline void to_json(json & j, const Staghunting & x) {
+        j = json::object();
+        j["calorimetric"] = x.get_calorimetric();
+        j["canid"] = x.get_canid();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ditriglyphic"] = x.get_ditriglyphic();
+        j["floriferousness"] = x.get_floriferousness();
+        j["gamelike"] = x.get_gamelike();
+        j["grig"] = x.get_grig();
+        j["homocerc"] = x.get_homocerc();
+        j["interloan"] = x.get_interloan();
+        j["lithotomy"] = x.get_lithotomy();
+        j["loric"] = x.get_loric();
+        j["membranocoriaceous"] = x.get_membranocoriaceous();
+        j["membranogenic"] = x.get_membranogenic();
+        j["nonbookish"] = x.get_nonbookish();
+        j["overtrump"] = x.get_overtrump();
+        j["scotino"] = x.get_scotino();
+        j["seasonable"] = x.get_seasonable();
+        j["sephen"] = x.get_sephen();
+        j["stigmarioid"] = x.get_stigmarioid();
+        j["tired"] = x.get_tired();
+        j["trifid"] = x.get_trifid();
+        j["undefeatedly"] = x.get_undefeatedly();
+        j["ungirlish"] = x.get_ungirlish();
+    }
+
+    inline void from_json(const json & j, StrenuosityClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_bliss(get_stack_optional<int64_t>(j, "bliss"));
+        x.set_buccate(get_stack_optional<int64_t>(j, "buccate"));
+        x.set_bulletproof(get_stack_optional<int64_t>(j, "bulletproof"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_crumblingness(get_stack_optional<int64_t>(j, "crumblingness"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_engagedly(get_stack_optional<int64_t>(j, "engagedly"));
+        x.set_fightable(get_stack_optional<int64_t>(j, "fightable"));
+        x.set_hoariness(get_stack_optional<int64_t>(j, "hoariness"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_hypopodium(get_stack_optional<int64_t>(j, "hypopodium"));
+        x.set_luxurist(get_stack_optional<int64_t>(j, "luxurist"));
+        x.set_mechanician(get_stack_optional<int64_t>(j, "mechanician"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_onopordon(get_stack_optional<int64_t>(j, "Onopordon"));
+        x.set_podgily(get_stack_optional<int64_t>(j, "podgily"));
+        x.set_reformableness(get_stack_optional<int64_t>(j, "reformableness"));
+        x.set_scatterbrains(get_stack_optional<int64_t>(j, "scatterbrains"));
+        x.set_seminuria(get_stack_optional<int64_t>(j, "seminuria"));
+        x.set_sodomite(get_stack_optional<int64_t>(j, "Sodomite"));
+        x.set_tramp(get_stack_optional<int64_t>(j, "tramp"));
+        x.set_undueness(get_stack_optional<int64_t>(j, "undueness"));
+        x.set_worthily(get_stack_optional<int64_t>(j, "worthily"));
+        x.set_yankeeist(get_stack_optional<int64_t>(j, "Yankeeist"));
+    }
+
+    inline void to_json(json & j, const StrenuosityClass & x) {
+        j = json::object();
+        j["bliss"] = x.get_bliss();
+        j["buccate"] = x.get_buccate();
+        j["bulletproof"] = x.get_bulletproof();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["crumblingness"] = x.get_crumblingness();
+        j["disdiapason"] = x.get_disdiapason();
+        j["engagedly"] = x.get_engagedly();
+        j["fightable"] = x.get_fightable();
+        j["hoariness"] = x.get_hoariness();
+        j["homocerc"] = x.get_homocerc();
+        j["hypopodium"] = x.get_hypopodium();
+        j["luxurist"] = x.get_luxurist();
+        j["mechanician"] = x.get_mechanician();
+        j["nonbookish"] = x.get_nonbookish();
+        j["Onopordon"] = x.get_onopordon();
+        j["podgily"] = x.get_podgily();
+        j["reformableness"] = x.get_reformableness();
+        j["scatterbrains"] = x.get_scatterbrains();
+        j["seminuria"] = x.get_seminuria();
+        j["Sodomite"] = x.get_sodomite();
+        j["tramp"] = x.get_tramp();
+        j["undueness"] = x.get_undueness();
+        j["worthily"] = x.get_worthily();
+        j["Yankeeist"] = x.get_yankeeist();
+    }
+
+    inline void from_json(const json & j, TruantcyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alfiona(get_untyped(j, "alfiona"));
+        x.set_ascaridiasis(get_untyped(j, "ascaridiasis"));
+        x.set_bungey(get_untyped(j, "bungey"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_ceroxyle(get_untyped(j, "ceroxyle"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chorology(get_untyped(j, "chorology"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_enmarble(get_untyped(j, "enmarble"));
+        x.set_epeira(get_untyped(j, "Epeira"));
+        x.set_eurylaimi(get_untyped(j, "Eurylaimi"));
+        x.set_germination(get_untyped(j, "germination"));
+        x.set_hallelujah(get_untyped(j, "hallelujah"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_lev(get_untyped(j, "lev"));
+        x.set_mouthing(get_untyped(j, "mouthing"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_philliloo(get_untyped(j, "philliloo"));
+        x.set_planetal(get_untyped(j, "planetal"));
+        x.set_poney(get_untyped(j, "poney"));
+        x.set_punctualist(get_untyped(j, "punctualist"));
+        x.set_returnlessly(get_untyped(j, "returnlessly"));
+        x.set_skelder(get_untyped(j, "skelder"));
+        x.set_windwaywardly(get_untyped(j, "windwaywardly"));
+        x.set_yuman(get_untyped(j, "Yuman"));
+    }
+
+    inline void to_json(json & j, const TruantcyClass & x) {
+        j = json::object();
+        j["alfiona"] = x.get_alfiona();
+        j["ascaridiasis"] = x.get_ascaridiasis();
+        j["bungey"] = x.get_bungey();
+        j["catharticalness"] = x.get_catharticalness();
+        j["ceroxyle"] = x.get_ceroxyle();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chorology"] = x.get_chorology();
+        j["disdiapason"] = x.get_disdiapason();
+        j["enmarble"] = x.get_enmarble();
+        j["Epeira"] = x.get_epeira();
+        j["Eurylaimi"] = x.get_eurylaimi();
+        j["germination"] = x.get_germination();
+        j["hallelujah"] = x.get_hallelujah();
+        j["homocerc"] = x.get_homocerc();
+        j["lev"] = x.get_lev();
+        j["mouthing"] = x.get_mouthing();
+        j["nonbookish"] = x.get_nonbookish();
+        j["philliloo"] = x.get_philliloo();
+        j["planetal"] = x.get_planetal();
+        j["poney"] = x.get_poney();
+        j["punctualist"] = x.get_punctualist();
+        j["returnlessly"] = x.get_returnlessly();
+        j["skelder"] = x.get_skelder();
+        j["windwaywardly"] = x.get_windwaywardly();
+        j["Yuman"] = x.get_yuman();
+    }
+
+    inline void from_json(const json & j, UnimpeachablyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_acerin(get_stack_optional<int64_t>(j, "acerin"));
+        x.set_bobadil(get_stack_optional<int64_t>(j, "Bobadil"));
+        x.set_catharticalness(get_stack_optional<double>(j, "catharticalness"));
+        x.set_chirotherium(get_stack_optional<int64_t>(j, "Chirotherium"));
+        x.set_chlorophylligenous(get_stack_optional<int64_t>(j, "chlorophylligenous"));
+        x.set_conversational(get_stack_optional<int64_t>(j, "conversational"));
+        x.set_demiowl(get_stack_optional<int64_t>(j, "demiowl"));
+        x.set_disdiapason(get_stack_optional<std::string>(j, "disdiapason"));
+        x.set_ectorhinal(get_stack_optional<int64_t>(j, "ectorhinal"));
+        x.set_gamblesomeness(get_stack_optional<int64_t>(j, "gamblesomeness"));
+        x.set_homocerc(get_stack_optional<bool>(j, "homocerc"));
+        x.set_irrorate(get_stack_optional<int64_t>(j, "irrorate"));
+        x.set_kindergartening(get_stack_optional<int64_t>(j, "kindergartening"));
+        x.set_lateritic(get_stack_optional<int64_t>(j, "lateritic"));
+        x.set_mespil(get_stack_optional<int64_t>(j, "mespil"));
+        x.set_misconfiguration(get_stack_optional<int64_t>(j, "misconfiguration"));
+        x.set_nonbookish(get_untyped(j, "nonbookish"));
+        x.set_planometry(get_stack_optional<int64_t>(j, "planometry"));
+        x.set_quiina(get_stack_optional<int64_t>(j, "Quiina"));
+        x.set_robert(get_stack_optional<int64_t>(j, "Robert"));
+        x.set_rot(get_stack_optional<int64_t>(j, "rot"));
+        x.set_subcinctorium(get_stack_optional<int64_t>(j, "subcinctorium"));
+        x.set_tussocker(get_stack_optional<int64_t>(j, "tussocker"));
+        x.set_ultraproud(get_stack_optional<int64_t>(j, "ultraproud"));
+        x.set_unsuggestedness(get_stack_optional<int64_t>(j, "unsuggestedness"));
+    }
+
+    inline void to_json(json & j, const UnimpeachablyClass & x) {
+        j = json::object();
+        j["acerin"] = x.get_acerin();
+        j["Bobadil"] = x.get_bobadil();
+        j["catharticalness"] = x.get_catharticalness();
+        j["Chirotherium"] = x.get_chirotherium();
+        j["chlorophylligenous"] = x.get_chlorophylligenous();
+        j["conversational"] = x.get_conversational();
+        j["demiowl"] = x.get_demiowl();
+        j["disdiapason"] = x.get_disdiapason();
+        j["ectorhinal"] = x.get_ectorhinal();
+        j["gamblesomeness"] = x.get_gamblesomeness();
+        j["homocerc"] = x.get_homocerc();
+        j["irrorate"] = x.get_irrorate();
+        j["kindergartening"] = x.get_kindergartening();
+        j["lateritic"] = x.get_lateritic();
+        j["mespil"] = x.get_mespil();
+        j["misconfiguration"] = x.get_misconfiguration();
+        j["nonbookish"] = x.get_nonbookish();
+        j["planometry"] = x.get_planometry();
+        j["Quiina"] = x.get_quiina();
+        j["Robert"] = x.get_robert();
+        j["rot"] = x.get_rot();
+        j["subcinctorium"] = x.get_subcinctorium();
+        j["tussocker"] = x.get_tussocker();
+        j["ultraproud"] = x.get_ultraproud();
+        j["unsuggestedness"] = x.get_unsuggestedness();
+    }
+
+    inline void from_json(const json & j, UnstressedClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_alain(get_untyped(j, "Alain"));
+        x.set_amphirhina(get_untyped(j, "Amphirhina"));
+        x.set_antimachinery(get_untyped(j, "antimachinery"));
+        x.set_coldish(get_untyped(j, "coldish"));
+        x.set_crantara(get_untyped(j, "crantara"));
+        x.set_distinguishing(get_untyped(j, "distinguishing"));
+        x.set_elytroposis(get_untyped(j, "elytroposis"));
+        x.set_gentianwort(get_untyped(j, "gentianwort"));
+        x.set_heliosis(get_untyped(j, "heliosis"));
+        x.set_instrumental(get_untyped(j, "instrumental"));
+        x.set_introinflection(get_untyped(j, "introinflection"));
+        x.set_kala(get_untyped(j, "kala"));
+        x.set_lincolnian(get_untyped(j, "Lincolnian"));
+        x.set_metad(get_untyped(j, "metad"));
+        x.set_sarcophilus(get_untyped(j, "Sarcophilus"));
+        x.set_swingingly(get_untyped(j, "swingingly"));
+        x.set_unconformity(get_untyped(j, "unconformity"));
+        x.set_undecreed(get_untyped(j, "undecreed"));
+        x.set_venerable(get_untyped(j, "venerable"));
+        x.set_vowellessness(get_untyped(j, "vowellessness"));
+    }
+
+    inline void to_json(json & j, const UnstressedClass & x) {
+        j = json::object();
+        j["Alain"] = x.get_alain();
+        j["Amphirhina"] = x.get_amphirhina();
+        j["antimachinery"] = x.get_antimachinery();
+        j["coldish"] = x.get_coldish();
+        j["crantara"] = x.get_crantara();
+        j["distinguishing"] = x.get_distinguishing();
+        j["elytroposis"] = x.get_elytroposis();
+        j["gentianwort"] = x.get_gentianwort();
+        j["heliosis"] = x.get_heliosis();
+        j["instrumental"] = x.get_instrumental();
+        j["introinflection"] = x.get_introinflection();
+        j["kala"] = x.get_kala();
+        j["Lincolnian"] = x.get_lincolnian();
+        j["metad"] = x.get_metad();
+        j["Sarcophilus"] = x.get_sarcophilus();
+        j["swingingly"] = x.get_swingingly();
+        j["unconformity"] = x.get_unconformity();
+        j["undecreed"] = x.get_undecreed();
+        j["venerable"] = x.get_venerable();
+        j["vowellessness"] = x.get_vowellessness();
+    }
+
+    inline void from_json(const json & j, WrothyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_aeschynanthus(get_untyped(j, "Aeschynanthus"));
+        x.set_aquiferous(get_untyped(j, "aquiferous"));
+        x.set_cheapener(get_untyped(j, "cheapener"));
+        x.set_enumeration(get_untyped(j, "enumeration"));
+        x.set_ephesine(get_untyped(j, "Ephesine"));
+        x.set_escadrille(get_untyped(j, "escadrille"));
+        x.set_estrous(get_untyped(j, "estrous"));
+        x.set_interestedly(get_untyped(j, "interestedly"));
+        x.set_katakinetomer(get_untyped(j, "katakinetomer"));
+        x.set_mortification(get_untyped(j, "mortification"));
+        x.set_morula(get_untyped(j, "morula"));
+        x.set_orthosymmetrical(get_untyped(j, "orthosymmetrical"));
+        x.set_overbark(get_untyped(j, "overbark"));
+        x.set_politist(get_untyped(j, "politist"));
+        x.set_qualified(get_untyped(j, "qualified"));
+        x.set_sphenomalar(get_untyped(j, "sphenomalar"));
+        x.set_throatful(get_untyped(j, "throatful"));
+        x.set_transhumance(get_untyped(j, "transhumance"));
+        x.set_triandrian(get_untyped(j, "triandrian"));
+        x.set_unbooked(get_untyped(j, "unbooked"));
+    }
+
+    inline void to_json(json & j, const WrothyClass & x) {
+        j = json::object();
+        j["Aeschynanthus"] = x.get_aeschynanthus();
+        j["aquiferous"] = x.get_aquiferous();
+        j["cheapener"] = x.get_cheapener();
+        j["enumeration"] = x.get_enumeration();
+        j["Ephesine"] = x.get_ephesine();
+        j["escadrille"] = x.get_escadrille();
+        j["estrous"] = x.get_estrous();
+        j["interestedly"] = x.get_interestedly();
+        j["katakinetomer"] = x.get_katakinetomer();
+        j["mortification"] = x.get_mortification();
+        j["morula"] = x.get_morula();
+        j["orthosymmetrical"] = x.get_orthosymmetrical();
+        j["overbark"] = x.get_overbark();
+        j["politist"] = x.get_politist();
+        j["qualified"] = x.get_qualified();
+        j["sphenomalar"] = x.get_sphenomalar();
+        j["throatful"] = x.get_throatful();
+        j["transhumance"] = x.get_transhumance();
+        j["triandrian"] = x.get_triandrian();
+        j["unbooked"] = x.get_unbooked();
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_protrusive(j.at("protrusive").get<std::vector<Protrusive>>());
+        x.set_pulpitism(j.at("pulpitism").get<std::vector<PulpitismElement>>());
+        x.set_pyodermia(j.at("pyodermia").get<std::vector<PyodermiaElement>>());
+        x.set_quebrachine(j.at("quebrachine").get<std::vector<QuebrachineElement>>());
+        x.set_querier(j.at("querier").get<std::vector<Querier>>());
+        x.set_rebarbative(j.at("rebarbative").get<std::vector<Rebarbative>>());
+        x.set_reimagine(j.at("reimagine").get<std::vector<Reimagine>>());
+        x.set_ressaut(j.at("ressaut").get<Ressaut>());
+        x.set_retrocervical(j.at("retrocervical").get<std::vector<Retrocervical>>());
+        x.set_revert(j.at("revert").get<std::vector<Revert>>());
+        x.set_rewrite(j.at("rewrite").get<std::vector<RewriteElement>>());
+        x.set_saccoderm(j.at("saccoderm").get<std::vector<Saccoderm>>());
+        x.set_santir(j.at("santir").get<std::vector<SantirElement>>());
+        x.set_saprophilous(j.at("saprophilous").get<std::vector<Saprophilous>>());
+        x.set_saxten(j.at("saxten").get<std::vector<SaxtenElement>>());
+        x.set_scatty(j.at("scatty").get<std::vector<std::optional<Scatty>>>());
+        x.set_scoffer(j.at("scoffer").get<std::vector<Scoffer>>());
+        x.set_scrampum(j.at("scrampum").get<std::vector<Scrampum>>());
+        x.set_semantic(j.at("semantic").get<double>());
+        x.set_serpentinic(j.at("serpentinic").get<std::vector<Serpentinic>>());
+        x.set_shadowable(j.at("shadowable").get<std::vector<Shadowable>>());
+        x.set_sistering(j.at("sistering").get<std::vector<SisteringElement>>());
+        x.set_staghunting(j.at("staghunting").get<std::vector<Staghunting>>());
+        x.set_stagmometer(j.at("stagmometer").get<std::vector<Stagmometer>>());
+        x.set_stimulability(j.at("stimulability").get<std::vector<Stimulability>>());
+        x.set_strangleable(j.at("strangleable").get<std::vector<Strangleable>>());
+        x.set_strenuosity(j.at("strenuosity").get<std::vector<StrenuosityElement>>());
+        x.set_tabaxir(j.at("tabaxir").get<std::vector<Tabaxir>>());
+        x.set_talpiform(j.at("talpiform").get<std::vector<Talpiform>>());
+        x.set_thwack(j.at("thwack").get<std::vector<Thwack>>());
+        x.set_to(j.at("to").get<std::vector<std::optional<double>>>());
+        x.set_tortricine(j.at("tortricine").get<std::vector<Tortricine>>());
+        x.set_truantcy(j.at("truantcy").get<std::vector<TruantcyElement>>());
+        x.set_turgesce(j.at("turgesce").get<std::vector<std::string>>());
+        x.set_unbeginning(j.at("unbeginning").get<std::vector<Unbeginning>>());
+        x.set_underdunged(j.at("underdunged").get<std::vector<double>>());
+        x.set_undesirability(j.at("undesirability").get<std::vector<Undesirability>>());
+        x.set_unerasing(j.at("unerasing").get<std::vector<Unerasing>>());
+        x.set_unguentarium(j.at("unguentarium").get<std::vector<Unguentarium>>());
+        x.set_unimpeachably(j.at("unimpeachably").get<std::vector<UnimpeachablyElement>>());
+        x.set_unmortgaged(j.at("unmortgaged").get<std::vector<Unmortgaged>>());
+        x.set_unobstructed(j.at("unobstructed").get<std::vector<Unobstructed>>());
+        x.set_unreceptivity(j.at("unreceptivity").get<std::vector<Unreceptivity>>());
+        x.set_unsatisfactoriness(j.at("unsatisfactoriness").get<std::vector<Unsatisfactoriness>>());
+        x.set_unsecurity(j.at("unsecurity").get<std::vector<int64_t>>());
+        x.set_unstressed(j.at("unstressed").get<std::vector<UnstressedElement>>());
+        x.set_untasked(j.at("untasked").get<std::vector<Untasked>>());
+        x.set_unvarying(j.at("unvarying").get<std::vector<Unvarying>>());
+        x.set_vehemently(j.at("vehemently").get<std::vector<Vehemently>>());
+        x.set_warriorship(j.at("warriorship").get<std::map<std::string, bool>>());
+        x.set_whitepot(j.at("whitepot").get<std::vector<Whitepot>>());
+        x.set_wrothy(j.at("wrothy").get<std::vector<WrothyElement>>());
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["protrusive"] = x.get_protrusive();
+        j["pulpitism"] = x.get_pulpitism();
+        j["pyodermia"] = x.get_pyodermia();
+        j["quebrachine"] = x.get_quebrachine();
+        j["querier"] = x.get_querier();
+        j["rebarbative"] = x.get_rebarbative();
+        j["reimagine"] = x.get_reimagine();
+        j["ressaut"] = x.get_ressaut();
+        j["retrocervical"] = x.get_retrocervical();
+        j["revert"] = x.get_revert();
+        j["rewrite"] = x.get_rewrite();
+        j["saccoderm"] = x.get_saccoderm();
+        j["santir"] = x.get_santir();
+        j["saprophilous"] = x.get_saprophilous();
+        j["saxten"] = x.get_saxten();
+        j["scatty"] = x.get_scatty();
+        j["scoffer"] = x.get_scoffer();
+        j["scrampum"] = x.get_scrampum();
+        j["semantic"] = x.get_semantic();
+        j["serpentinic"] = x.get_serpentinic();
+        j["shadowable"] = x.get_shadowable();
+        j["sistering"] = x.get_sistering();
+        j["staghunting"] = x.get_staghunting();
+        j["stagmometer"] = x.get_stagmometer();
+        j["stimulability"] = x.get_stimulability();
+        j["strangleable"] = x.get_strangleable();
+        j["strenuosity"] = x.get_strenuosity();
+        j["tabaxir"] = x.get_tabaxir();
+        j["talpiform"] = x.get_talpiform();
+        j["thwack"] = x.get_thwack();
+        j["to"] = x.get_to();
+        j["tortricine"] = x.get_tortricine();
+        j["truantcy"] = x.get_truantcy();
+        j["turgesce"] = x.get_turgesce();
+        j["unbeginning"] = x.get_unbeginning();
+        j["underdunged"] = x.get_underdunged();
+        j["undesirability"] = x.get_undesirability();
+        j["unerasing"] = x.get_unerasing();
+        j["unguentarium"] = x.get_unguentarium();
+        j["unimpeachably"] = x.get_unimpeachably();
+        j["unmortgaged"] = x.get_unmortgaged();
+        j["unobstructed"] = x.get_unobstructed();
+        j["unreceptivity"] = x.get_unreceptivity();
+        j["unsatisfactoriness"] = x.get_unsatisfactoriness();
+        j["unsecurity"] = x.get_unsecurity();
+        j["unstressed"] = x.get_unstressed();
+        j["untasked"] = x.get_untasked();
+        j["unvarying"] = x.get_unvarying();
+        j["vehemently"] = x.get_vehemently();
+        j["warriorship"] = x.get_warriorship();
+        j["whitepot"] = x.get_whitepot();
+        j["wrothy"] = x.get_wrothy();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, double>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::PulpitismClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, quicktype::PulpitismClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::PulpitismClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>>::from_json(const json & j, std::variant<quicktype::PyodermiaClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::PyodermiaClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::PyodermiaClass, int64_t>>::to_json(json & j, const std::variant<quicktype::PyodermiaClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::PyodermiaClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass>>::from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass>>::to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, int64_t>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::from_json(const json & j, std::variant<bool, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, std::string>>::to_json(json & j, const std::variant<bool, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::RewriteClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::RewriteClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::RewriteClass, double>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::RewriteClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::RewriteClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SantirClass, double>>::from_json(const json & j, std::variant<quicktype::SantirClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::SantirClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SantirClass, double>>::to_json(json & j, const std::variant<quicktype::SantirClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SantirClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SaxtenClass, std::string>>::from_json(const json & j, std::variant<quicktype::SaxtenClass, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::SaxtenClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SaxtenClass, std::string>>::to_json(json & j, const std::variant<quicktype::SaxtenClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SaxtenClass>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::from_json(const json & j, std::variant<std::vector<int64_t>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, double>>::to_json(json & j, const std::variant<std::vector<int64_t>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, bool>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::SisteringClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::SisteringClass, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::SisteringClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::SisteringClass>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, std::string>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::from_json(const json & j, std::variant<std::vector<json>, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double>>::to_json(json & j, const std::variant<std::vector<json>, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::StrenuosityClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::StrenuosityClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::StrenuosityClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::StrenuosityClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::StrenuosityClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::from_json(const json & j, std::variant<bool, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double>>::to_json(json & j, const std::variant<bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, double>>::from_json(const json & j, std::variant<quicktype::QuebrachineClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, double>>::to_json(json & j, const std::variant<quicktype::QuebrachineClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>>::from_json(const json & j, std::variant<bool, quicktype::QuebrachineClass, double> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::QuebrachineClass, double>>::to_json(json & j, const std::variant<bool, quicktype::QuebrachineClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 2:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>>::from_json(const json & j, std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<std::optional<int64_t>>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass>>::to_json(json & j, const std::variant<std::vector<std::optional<int64_t>>, quicktype::QuebrachineClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<std::optional<int64_t>>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::TruantcyClass>>::from_json(const json & j, std::variant<bool, quicktype::TruantcyClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::TruantcyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::TruantcyClass>>::to_json(json & j, const std::variant<bool, quicktype::TruantcyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::TruantcyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<json>, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>>::from_json(const json & j, std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x) {
+        if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string>>::to_json(json & j, const std::variant<std::vector<int64_t>, std::map<std::string, int64_t>, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, int64_t, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::from_json(const json & j, std::variant<std::vector<json>, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t>>::to_json(json & j, const std::variant<std::vector<json>, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>>::from_json(const json & j, std::variant<bool, quicktype::UnimpeachablyClass> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnimpeachablyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnimpeachablyClass>>::to_json(json & j, const std::variant<bool, quicktype::UnimpeachablyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::UnimpeachablyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<double>(x);
+                break;
+            case 1:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>>::from_json(const json & j, std::variant<quicktype::QuebrachineClass, int64_t> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_object())
+            x = j.get<quicktype::QuebrachineClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::QuebrachineClass, int64_t>>::to_json(json & j, const std::variant<quicktype::QuebrachineClass, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::QuebrachineClass>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::string>>::from_json(const json & j, std::variant<std::vector<json>, int64_t, std::string> & x) {
+        if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, int64_t, std::string>>::to_json(json & j, const std::variant<std::vector<json>, int64_t, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<int64_t>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>>::from_json(const json & j, std::variant<std::vector<int64_t>, bool, int64_t> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number_integer())
+            x = j.get<int64_t>();
+        else if (j.is_array())
+            x = j.get<std::vector<int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<int64_t>, bool, int64_t>>::to_json(json & j, const std::variant<std::vector<int64_t>, bool, int64_t> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<int64_t>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            case 2:
+                j = std::get<int64_t>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>>::from_json(const json & j, std::variant<bool, quicktype::UnstressedClass, std::string> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_string())
+            x = j.get<std::string>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnstressedClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, quicktype::UnstressedClass, std::string>>::to_json(json & j, const std::variant<bool, quicktype::UnstressedClass, std::string> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::UnstressedClass>(x);
+                break;
+            case 2:
+                j = std::get<std::string>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<std::vector<json>, double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>>::from_json(const json & j, std::variant<bool, double, std::map<std::string, int64_t>> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<std::map<std::string, int64_t>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<bool, double, std::map<std::string, int64_t>>>::to_json(json & j, const std::variant<bool, double, std::map<std::string, int64_t>> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            case 2:
+                j = std::get<std::map<std::string, int64_t>>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::from_json(const json & j, std::variant<std::vector<json>, bool> & x) {
+        if (j.is_boolean())
+            x = j.get<bool>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, bool>>::to_json(json & j, const std::variant<std::vector<json>, bool> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<bool>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>>::from_json(const json & j, std::variant<std::vector<json>, quicktype::WrothyClass> & x) {
+        if (j.is_object())
+            x = j.get<quicktype::WrothyClass>();
+        else if (j.is_array())
+            x = j.get<std::vector<json>>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<std::vector<json>, quicktype::WrothyClass>>::to_json(json & j, const std::variant<std::vector<json>, quicktype::WrothyClass> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<std::vector<json>>(x);
+                break;
+            case 1:
+                j = std::get<quicktype::WrothyClass>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/crystal/test/inputs/json/misc/00c36.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/00c36.json/default/TopLevel.cr
new file mode 100644
index 0000000..4b9cdae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/00c36.json/default/TopLevel.cr
@@ -0,0 +1,39 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  property country : Country
+
+  property date : String
+
+  property decimal : String
+
+  property indicator : Country
+
+  property value : String
+end
+
+class Country
+  include JSON::Serializable
+
+  property id : String
+
+  property value : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  property page : Int32
+
+  property pages : Int32
+
+  property per_page : String
+
+  property total : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/misc/00ec5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/00ec5.json/default/TopLevel.cr
new file mode 100644
index 0000000..a9250ce
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/00ec5.json/default/TopLevel.cr
@@ -0,0 +1,121 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "basePath")]
+  property base_path : String
+
+  property definitions : Definitions
+
+  property host : String
+
+  property info : Info
+
+  property paths : Paths
+
+  property produces : Array(String)
+
+  property schemes : Array(String)
+
+  property swagger : String
+end
+
+class Definitions
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Provider")]
+  property provider : Provider
+end
+
+class Provider
+  include JSON::Serializable
+
+  property properties : Hash(String, Property)
+end
+
+class Property
+  include JSON::Serializable
+
+  property description : String
+
+  @[JSON::Field(key: "type")]
+  property property_type : String
+end
+
+class Info
+  include JSON::Serializable
+
+  property description : String
+
+  property title : String
+
+  property version : String
+end
+
+class Paths
+  include JSON::Serializable
+
+  @[JSON::Field(key: "/business_service_providers/search")]
+  property business_service_providers_search : BusinessServiceProvidersSearch
+end
+
+class BusinessServiceProvidersSearch
+  include JSON::Serializable
+
+  property get : Get
+end
+
+class Get
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : Responses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class Parameter
+  include JSON::Serializable
+
+  property description : String
+
+  property format : String
+
+  property name : String
+
+  @[JSON::Field(key: "in")]
+  property parameter_in : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : String
+
+  property required : Bool
+end
+
+class Responses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : The200
+end
+
+class The200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : Schema
+end
+
+class Schema
+  include JSON::Serializable
+
+  @[JSON::Field(key: "$ref")]
+  property ref : String
+end
diff --git a/head/crystal/test/inputs/json/misc/010b1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/010b1.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/010b1.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/016af.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/016af.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/016af.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/033b1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/033b1.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/033b1.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/050b0.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/050b0.json/default/TopLevel.cr
new file mode 100644
index 0000000..6d7a453
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/050b0.json/default/TopLevel.cr
@@ -0,0 +1,57 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(OtherName)
+
+  property superseded_by : String?
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class OtherName
+  include JSON::Serializable
+
+  property name : String
+
+  property note : String?
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/06bee.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/06bee.json/default/TopLevel.cr
new file mode 100644
index 0000000..8c033c5
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/06bee.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : Nil
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/07540.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/07540.json/default/TopLevel.cr
new file mode 100644
index 0000000..90a4346
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/07540.json/default/TopLevel.cr
@@ -0,0 +1,12 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property cookies : Cookies
+end
+
+class Cookies
+  include JSON::Serializable
+
+end
diff --git a/head/crystal/test/inputs/json/misc/0779f.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0779f.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0779f.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/07c75.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/07c75.json/default/TopLevel.cr
new file mode 100644
index 0000000..8c033c5
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/07c75.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : Nil
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/09f54.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/09f54.json/default/TopLevel.cr
new file mode 100644
index 0000000..c658019
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/09f54.json/default/TopLevel.cr
@@ -0,0 +1,29 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Hash(String, Datum)
+
+  property description : Description
+end
+
+class Datum
+  include JSON::Serializable
+
+  property anomaly : String
+
+  property value : String
+end
+
+class Description
+  include JSON::Serializable
+
+  property base_period : String
+
+  property missing : Int32
+
+  property title : String
+
+  property units : String
+end
diff --git a/head/crystal/test/inputs/json/misc/0a358.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0a358.json/default/TopLevel.cr
new file mode 100644
index 0000000..dd11d60
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0a358.json/default/TopLevel.cr
@@ -0,0 +1,41 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property code : String
+
+  property created_at : String
+
+  property id : Int32
+
+  property name : String
+
+  property updated_at : String
+
+  property uri : String
+end
diff --git a/head/crystal/test/inputs/json/misc/0a91a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0a91a.json/default/TopLevel.cr
new file mode 100644
index 0000000..6485dbc
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0a91a.json/default/TopLevel.cr
@@ -0,0 +1,414 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property actor : Actor
+
+  property created_at : String
+
+  property id : String
+
+  property org : Actor?
+
+  property payload : Payload
+
+  property public : Bool
+
+  property repo : TopLevelRepo
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Actor
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property display_login : String?
+
+  property gravatar_id : String
+
+  property id : Int32
+
+  property login : String
+
+  property url : String
+end
+
+class Payload
+  include JSON::Serializable
+
+  property action : String?
+
+  property before : String?
+
+  property commits : Array(Commit)?
+
+  property description : String?
+
+  property distinct_size : Int32?
+
+  property head : String?
+
+  property master_branch : String?
+
+  property number : Int32?
+
+  property pull_request : PullRequest?
+
+  property push_id : Int32?
+
+  property pusher_type : String?
+
+  property ref : String?
+
+  property ref_type : String?
+
+  property size : Int32?
+end
+
+class Commit
+  include JSON::Serializable
+
+  property author : Author
+
+  property distinct : Bool
+
+  property message : String
+
+  property sha : String
+
+  property url : String
+end
+
+class Author
+  include JSON::Serializable
+
+  property email : String
+
+  property name : String
+end
+
+class PullRequest
+  include JSON::Serializable
+
+  property additions : Int32
+
+  property assignee : Nil
+
+  property assignees : Array(JSON::Any?)
+
+  property base : Base
+
+  property body : String
+
+  property changed_files : Int32
+
+  property closed_at : String
+
+  property comments : Int32
+
+  property comments_url : String
+
+  property commits : Int32
+
+  property commits_url : String
+
+  property created_at : String
+
+  property deletions : Int32
+
+  property diff_url : String
+
+  property head : Base
+
+  property html_url : String
+
+  property id : Int32
+
+  property issue_url : String
+
+  @[JSON::Field(key: "_links")]
+  property links : Links
+
+  property locked : Bool
+
+  property maintainer_can_modify : Bool
+
+  property merge_commit_sha : String
+
+  property mergeable : Nil
+
+  property mergeable_state : String
+
+  property merged : Bool
+
+  property merged_at : String
+
+  property merged_by : MergedBy
+
+  property milestone : Nil
+
+  property number : Int32
+
+  property patch_url : String
+
+  property rebaseable : Nil
+
+  property requested_reviewers : Array(JSON::Any?)
+
+  property review_comment_url : String
+
+  property review_comments : Int32
+
+  property review_comments_url : String
+
+  property state : String
+
+  property statuses_url : String
+
+  property title : String
+
+  property updated_at : String
+
+  property url : String
+
+  property user : MergedBy
+end
+
+class Base
+  include JSON::Serializable
+
+  property label : String
+
+  property ref : String
+
+  property repo : BaseRepo
+
+  property sha : String
+
+  property user : MergedBy
+end
+
+class BaseRepo
+  include JSON::Serializable
+
+  property archive_url : String
+
+  property assignees_url : String
+
+  property blobs_url : String
+
+  property branches_url : String
+
+  property clone_url : String
+
+  property collaborators_url : String
+
+  property comments_url : String
+
+  property commits_url : String
+
+  property compare_url : String
+
+  property contents_url : String
+
+  property contributors_url : String
+
+  property created_at : String
+
+  property default_branch : String
+
+  property deployments_url : String
+
+  property description : Nil
+
+  property downloads_url : String
+
+  property events_url : String
+
+  property fork : Bool
+
+  property forks : Int32
+
+  property forks_count : Int32
+
+  property forks_url : String
+
+  property full_name : String
+
+  property git_commits_url : String
+
+  property git_refs_url : String
+
+  property git_tags_url : String
+
+  property git_url : String
+
+  property has_downloads : Bool
+
+  property has_issues : Bool
+
+  property has_pages : Bool
+
+  property has_projects : Bool
+
+  property has_wiki : Bool
+
+  property homepage : Nil
+
+  property hooks_url : String
+
+  property html_url : String
+
+  property id : Int32
+
+  property issue_comment_url : String
+
+  property issue_events_url : String
+
+  property issues_url : String
+
+  property keys_url : String
+
+  property labels_url : String
+
+  property language : String
+
+  property languages_url : String
+
+  property merges_url : String
+
+  property milestones_url : String
+
+  property mirror_url : Nil
+
+  property name : String
+
+  property notifications_url : String
+
+  property open_issues : Int32
+
+  property open_issues_count : Int32
+
+  property owner : MergedBy
+
+  property pulls_url : String
+
+  property pushed_at : String
+
+  property releases_url : String
+
+  @[JSON::Field(key: "private")]
+  property repo_private : Bool
+
+  property size : Int32
+
+  property ssh_url : String
+
+  property stargazers_count : Int32
+
+  property stargazers_url : String
+
+  property statuses_url : String
+
+  property subscribers_url : String
+
+  property subscription_url : String
+
+  property svn_url : String
+
+  property tags_url : String
+
+  property teams_url : String
+
+  property trees_url : String
+
+  property updated_at : String
+
+  property url : String
+
+  property watchers : Int32
+
+  property watchers_count : Int32
+end
+
+class MergedBy
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property events_url : String
+
+  property followers_url : String
+
+  property following_url : String
+
+  property gists_url : String
+
+  property gravatar_id : String
+
+  property html_url : String
+
+  property id : Int32
+
+  property login : String
+
+  @[JSON::Field(key: "type")]
+  property merged_by_type : String
+
+  property organizations_url : String
+
+  property received_events_url : String
+
+  property repos_url : String
+
+  property site_admin : Bool
+
+  property starred_url : String
+
+  property subscriptions_url : String
+
+  property url : String
+end
+
+class Links
+  include JSON::Serializable
+
+  property comments : Comments
+
+  property commits : Comments
+
+  property html : Comments
+
+  property issue : Comments
+
+  @[JSON::Field(key: "self")]
+  property links_self : Comments
+
+  property review_comment : Comments
+
+  property review_comments : Comments
+
+  property statuses : Comments
+end
+
+class Comments
+  include JSON::Serializable
+
+  property href : String
+end
+
+class TopLevelRepo
+  include JSON::Serializable
+
+  property id : Int32
+
+  property name : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/0b91a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0b91a.json/default/TopLevel.cr
new file mode 100644
index 0000000..94a8606
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0b91a.json/default/TopLevel.cr
@@ -0,0 +1,80 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property metadata : Metadata
+
+  property results : Array(Result)
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "executionTime")]
+  property execution_time : Float64
+
+  @[JSON::Field(key: "responseInfo")]
+  property response_info : ResponseInfo
+
+  property resultset : Resultset
+end
+
+class ResponseInfo
+  include JSON::Serializable
+
+  @[JSON::Field(key: "developerMessage")]
+  property developer_message : String
+
+  property status : Int32
+end
+
+class Resultset
+  include JSON::Serializable
+
+  property count : Int32
+
+  property page : Int32
+
+  property pagesize : Int32
+end
+
+class Result
+  include JSON::Serializable
+
+  property attachment : Array(JSON::Any?)
+
+  property body : String
+
+  property changed : String
+
+  property component : Array(Component)
+
+  property created : String
+
+  property date : String
+
+  property image : Array(JSON::Any?)
+
+  property number : Nil
+
+  property teaser : Nil
+
+  property title : String
+
+  property topic : Array(JSON::Any?)
+
+  property url : String
+
+  property uuid : String
+
+  property vuuid : String
+end
+
+class Component
+  include JSON::Serializable
+
+  property name : String
+
+  property uuid : String
+end
diff --git a/head/crystal/test/inputs/json/misc/0cffa.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0cffa.json/default/TopLevel.cr
new file mode 100644
index 0000000..88dfd89
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0cffa.json/default/TopLevel.cr
@@ -0,0 +1,195 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+
+  @[JSON::Field(key: "480w_still")]
+  property the_480_w_still : Downsized?
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/0e0c2.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0e0c2.json/default/TopLevel.cr
new file mode 100644
index 0000000..b46c73c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0e0c2.json/default/TopLevel.cr
@@ -0,0 +1,125 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property previous : Nil
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Result
+  include JSON::Serializable
+
+  property active_screens : Int32
+
+  property collections : Array(Collection)
+
+  property details : Array(Detail)
+
+  property duration : Int32
+
+  property fav_movie : FavMovie
+
+  property id : Int32
+
+  property images : Array(Image)
+
+  property language : String
+
+  property release_date : String
+
+  property stars : Int32
+
+  property tags : Array(JSON::Any?)?
+
+  property title : String
+
+  property videos : Array(Video)
+
+  property vote_score : VoteScore
+
+  property watches : Int32
+end
+
+class Collection
+  include JSON::Serializable
+
+  property id : Int32
+
+  property movies : Array(Int32)
+
+  property name : String
+
+  property slug : String
+end
+
+class Detail
+  include JSON::Serializable
+
+  property cast : String
+
+  property director : String
+
+  property id : Int32
+
+  property language : String
+
+  property storyline : String
+
+  property tagline : String
+
+  property title : String
+end
+
+class FavMovie
+  include JSON::Serializable
+
+  property follow : Bool
+
+  property star : Bool
+
+  property watched : Bool
+end
+
+class Image
+  include JSON::Serializable
+
+  property favs : Int32
+
+  property id : Int32
+
+  @[JSON::Field(key: "type")]
+  property image_type : String
+
+  property thumbnail : String
+
+  property url : String
+end
+
+class Video
+  include JSON::Serializable
+
+  property kind : String
+
+  property language : String
+
+  property source : String
+
+  property url : String
+end
+
+class VoteScore
+  include JSON::Serializable
+
+  property avg : Int32
+
+  property score : Int32
+
+  property total : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/0fecf.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/0fecf.json/default/TopLevel.cr
new file mode 100644
index 0000000..83f0e9a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/0fecf.json/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property countries : Array(String)
+end
diff --git a/head/crystal/test/inputs/json/misc/10be4.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/10be4.json/default/TopLevel.cr
new file mode 100644
index 0000000..6d7a453
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/10be4.json/default/TopLevel.cr
@@ -0,0 +1,57 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(OtherName)
+
+  property superseded_by : String?
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class OtherName
+  include JSON::Serializable
+
+  property name : String
+
+  property note : String?
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/112b5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/112b5.json/default/TopLevel.cr
new file mode 100644
index 0000000..ac985ae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/112b5.json/default/TopLevel.cr
@@ -0,0 +1,34 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property args : Args
+
+  property headers : Headers
+
+  property origin : String
+
+  property url : String
+end
+
+class Args
+  include JSON::Serializable
+
+end
+
+class Headers
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Accept-Encoding")]
+  property accept_encoding : String
+
+  @[JSON::Field(key: "Connection")]
+  property connection : String
+
+  @[JSON::Field(key: "Host")]
+  property host : String
+
+  @[JSON::Field(key: "User-Agent")]
+  property user_agent : String
+end
diff --git a/head/crystal/test/inputs/json/misc/127a1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/127a1.json/default/TopLevel.cr
new file mode 100644
index 0000000..5d22178
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/127a1.json/default/TopLevel.cr
@@ -0,0 +1,195 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+
+  @[JSON::Field(key: "480w_still")]
+  property the_480_w_still : Downsized?
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String?
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/13d8d.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/13d8d.json/default/TopLevel.cr
new file mode 100644
index 0000000..c219957
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/13d8d.json/default/TopLevel.cr
@@ -0,0 +1,51 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property category : String
+
+  property context : String
+
+  property id : Int32
+
+  property location : Location
+
+  property location_subtype : String
+
+  property location_type : String
+
+  property month : String
+
+  property outcome_status : OutcomeStatus
+
+  property persistent_id : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property latitude : String
+
+  property longitude : String
+
+  property street : Street
+end
+
+class Street
+  include JSON::Serializable
+
+  property id : Int32
+
+  property name : String
+end
+
+class OutcomeStatus
+  include JSON::Serializable
+
+  property category : String
+
+  property date : String
+end
diff --git a/head/crystal/test/inputs/json/misc/14d38.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/14d38.json/default/TopLevel.cr
new file mode 100644
index 0000000..9494547
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/14d38.json/default/TopLevel.cr
@@ -0,0 +1,23 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property headers : Headers
+end
+
+class Headers
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Accept-Encoding")]
+  property accept_encoding : String
+
+  @[JSON::Field(key: "Connection")]
+  property connection : String
+
+  @[JSON::Field(key: "Host")]
+  property host : String
+
+  @[JSON::Field(key: "User-Agent")]
+  property user_agent : String
+end
diff --git a/head/crystal/test/inputs/json/misc/167d6.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/167d6.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/167d6.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/16bc5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/16bc5.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/16bc5.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/176f1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/176f1.json/default/TopLevel.cr
new file mode 100644
index 0000000..54f6724
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/176f1.json/default/TopLevel.cr
@@ -0,0 +1,53 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property message : Array(JSON::Any?)
+
+  @[JSON::Field(key: "responseTime")]
+  property response_time : Int32
+
+  @[JSON::Field(key: "Results")]
+  property results : Results
+
+  property status : String
+end
+
+class Results
+  include JSON::Serializable
+
+  property series : Array(Series)
+end
+
+class Series
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  @[JSON::Field(key: "seriesID")]
+  property series_id : String
+end
+
+class Datum
+  include JSON::Serializable
+
+  property footnotes : Array(Footnote)
+
+  property period : String
+
+  @[JSON::Field(key: "periodName")]
+  property period_name : String
+
+  property value : String
+
+  property year : String
+end
+
+class Footnote
+  include JSON::Serializable
+
+  property code : String?
+
+  property text : String?
+end
diff --git a/head/crystal/test/inputs/json/misc/1a7f5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/1a7f5.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/1a7f5.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/1b28c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/1b28c.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/1b28c.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/1b409.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/1b409.json/default/TopLevel.cr
new file mode 100644
index 0000000..558cb8b
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/1b409.json/default/TopLevel.cr
@@ -0,0 +1,119 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property objects : Array(ObjectElement)
+end
+
+class Meta
+  include JSON::Serializable
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
+
+class ObjectElement
+  include JSON::Serializable
+
+  property caucus : Nil
+
+  property congress_numbers : Array(Int32)
+
+  property current : Bool
+
+  property description : String
+
+  property district : Int32
+
+  property enddate : String
+
+  property extra : Extra
+
+  property id : Int32
+
+  property leadership_title : String?
+
+  property party : String
+
+  property person : Person
+
+  property phone : String
+
+  property role_type : String
+
+  property role_type_label : String
+
+  property senator_class : Nil
+
+  property senator_rank : Nil
+
+  property startdate : String
+
+  property state : String
+
+  property title : String
+
+  property title_long : String
+
+  property website : String
+end
+
+class Extra
+  include JSON::Serializable
+
+  property address : String
+
+  property contact_form : String?
+
+  property fax : String?
+
+  property office : String
+
+  property rss_url : String?
+end
+
+class Person
+  include JSON::Serializable
+
+  property bioguideid : String
+
+  property birthday : String
+
+  property cspanid : Int32
+
+  property firstname : String
+
+  property gender : String
+
+  property gender_label : String
+
+  property id : Int32
+
+  property lastname : String
+
+  property link : String
+
+  property middlename : String
+
+  property name : String
+
+  property namemod : String
+
+  property nickname : String
+
+  property osid : String
+
+  property pvsid : String?
+
+  property sortname : String
+
+  property twitterid : String?
+
+  property youtubeid : String?
+end
diff --git a/head/crystal/test/inputs/json/misc/2465e.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/2465e.json/default/TopLevel.cr
new file mode 100644
index 0000000..d7b5851
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/2465e.json/default/TopLevel.cr
@@ -0,0 +1,138 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "basePath")]
+  property base_path : String
+
+  property definitions : Definitions
+
+  property host : String
+
+  property info : Info
+
+  property paths : Paths
+
+  property produces : Array(String)
+
+  property schemes : Array(String)
+
+  property swagger : String
+end
+
+class Definitions
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Taxonomy")]
+  property taxonomy : Taxonomy
+end
+
+class Taxonomy
+  include JSON::Serializable
+
+  property properties : Properties
+end
+
+class Properties
+  include JSON::Serializable
+
+  property annotations : Annotations
+
+  property datatype_properties : Annotations
+
+  property id : Annotations
+
+  property label : Annotations
+
+  @[JSON::Field(key: "type")]
+  property properties_type : Annotations
+
+  property sub_class_of : Annotations
+end
+
+class Annotations
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property annotations_type : String
+
+  property description : String
+end
+
+class Info
+  include JSON::Serializable
+
+  property description : String
+
+  property title : String
+
+  property version : String
+end
+
+class Paths
+  include JSON::Serializable
+
+  @[JSON::Field(key: "/ita_taxonomies/search")]
+  property ita_taxonomies_search : ItaTaxonomiesSearch
+end
+
+class ItaTaxonomiesSearch
+  include JSON::Serializable
+
+  property get : Get
+end
+
+class Get
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : Responses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class Parameter
+  include JSON::Serializable
+
+  property description : String
+
+  property format : String
+
+  property name : String
+
+  @[JSON::Field(key: "in")]
+  property parameter_in : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : String
+
+  property required : Bool
+end
+
+class Responses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : The200
+end
+
+class The200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : Schema
+end
+
+class Schema
+  include JSON::Serializable
+
+  @[JSON::Field(key: "$ref")]
+  property ref : String
+end
diff --git a/head/crystal/test/inputs/json/misc/24f52.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/24f52.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/24f52.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/262f0.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/262f0.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/262f0.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/26b49.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/26b49.json/default/TopLevel.cr
new file mode 100644
index 0000000..482e932
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/26b49.json/default/TopLevel.cr
@@ -0,0 +1,197 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property hd : DownsizedSmall?
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+
+  @[JSON::Field(key: "480w_still")]
+  property the_480_w_still : Downsized?
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String?
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/26c9c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/26c9c.json/default/TopLevel.cr
new file mode 100644
index 0000000..ad77803
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/26c9c.json/default/TopLevel.cr
@@ -0,0 +1,400 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum?))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  property attribution : String
+
+  @[JSON::Field(key: "attributionLink")]
+  property attribution_link : String
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  property description : String
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property locale : String
+
+  property metadata : Metadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  property tags : Array(String)
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Format
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property average : String?
+
+  property largest : String
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String
+
+  property sum : String?
+
+  property top : Array(Top)
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Format
+  include JSON::Serializable
+
+  property align : String?
+
+  @[JSON::Field(key: "noCommas")]
+  property no_commas : String?
+
+  @[JSON::Field(key: "precisionStyle")]
+  property precision_style : String?
+
+  property view : String?
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class Metadata
+  include JSON::Serializable
+
+  property attachments : Array(Attachment)
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  property custom_fields : CustomFields
+
+  @[JSON::Field(key: "jsonQuery")]
+  property json_query : JsonQuery
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+end
+
+class Attachment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "assetId")]
+  property asset_id : String
+
+  @[JSON::Field(key: "blobId")]
+  property blob_id : String
+
+  property filename : String
+
+  property name : String
+end
+
+class CustomFields
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Additional Resources")]
+  property additional_resources : AdditionalResources
+
+  @[JSON::Field(key: "Common Core")]
+  property common_core : CommonCore
+
+  @[JSON::Field(key: "Dataset Information")]
+  property dataset_information : DatasetInformation
+
+  @[JSON::Field(key: "Dataset Summary")]
+  property dataset_summary : DatasetSummary
+
+  @[JSON::Field(key: "Notes")]
+  property notes : Notes
+end
+
+class AdditionalResources
+  include JSON::Serializable
+
+  @[JSON::Field(key: "See Also ")]
+  property additional_resources_see_also : String
+
+  @[JSON::Field(key: "See Also")]
+  property see_also : String
+end
+
+class CommonCore
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Email")]
+  property contact_email : String
+
+  @[JSON::Field(key: "Contact Name")]
+  property contact_name : String
+
+  @[JSON::Field(key: "Publisher")]
+  property publisher : String
+end
+
+class DatasetInformation
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Agency")]
+  property agency : String
+end
+
+class DatasetSummary
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Information")]
+  property contact_information : String
+
+  @[JSON::Field(key: "Coverage")]
+  property coverage : String
+
+  @[JSON::Field(key: "Data Frequency")]
+  property data_frequency : String
+
+  @[JSON::Field(key: "Dataset Owner")]
+  property dataset_owner : String
+
+  @[JSON::Field(key: "Granularity")]
+  property granularity : String
+
+  @[JSON::Field(key: "Organization")]
+  property organization : String
+
+  @[JSON::Field(key: "Posting Frequency")]
+  property posting_frequency : String
+
+  @[JSON::Field(key: "Time Period")]
+  property time_period : String
+
+  @[JSON::Field(key: "Units")]
+  property units : String
+end
+
+class Notes
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Notes")]
+  property notes : String
+end
+
+class JsonQuery
+  include JSON::Serializable
+
+  property order : Array(Order)
+end
+
+class Order
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "profileImageUrlLarge")]
+  property profile_image_url_large : String
+
+  @[JSON::Field(key: "profileImageUrlMedium")]
+  property profile_image_url_medium : String
+
+  @[JSON::Field(key: "profileImageUrlSmall")]
+  property profile_image_url_small : String
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "roleName")]
+  property role_name : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+class Query
+  include JSON::Serializable
+
+  @[JSON::Field(key: "orderBys")]
+  property order_bys : Array(OrderBy)
+end
+
+class OrderBy
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  property expression : Expression
+end
+
+class Expression
+  include JSON::Serializable
+
+  @[JSON::Field(key: "columnId")]
+  property column_id : Int32
+
+  @[JSON::Field(key: "type")]
+  property expression_type : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/27332.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/27332.json/default/TopLevel.cr
new file mode 100644
index 0000000..1f06a2e
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/27332.json/default/TopLevel.cr
@@ -0,0 +1,246 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : String?
+
+  property author_flair_text : String?
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : String?
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : String?
+
+  property link_flair_text : String?
+
+  property locked : Bool
+
+  property media : Media?
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property post_hint : String?
+
+  property preview : Preview?
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Media?
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : String?
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : Nil
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32?
+
+  property thumbnail_width : Int32?
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class Media
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property media_type : String
+
+  property oembed : Oembed
+end
+
+class Oembed
+  include JSON::Serializable
+
+  property description : String
+
+  property height : Int32
+
+  property html : String
+
+  @[JSON::Field(key: "type")]
+  property oembed_type : String
+
+  property provider_name : String
+
+  property provider_url : String
+
+  property thumbnail_height : Int32
+
+  property thumbnail_url : String
+
+  property thumbnail_width : Int32
+
+  property title : String
+
+  property version : String
+
+  property width : Int32
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+  property content : String?
+
+  property height : Int32?
+
+  property scrolling : Bool?
+
+  property width : Int32?
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : Variants
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Variants
+  include JSON::Serializable
+
+end
diff --git a/head/crystal/test/inputs/json/misc/29f47.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/29f47.json/default/TopLevel.cr
new file mode 100644
index 0000000..2454248
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/29f47.json/default/TopLevel.cr
@@ -0,0 +1,214 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : Nil
+
+  property author_flair_text : Nil
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : String
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Edited
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : Nil
+
+  property link_flair_text : Nil
+
+  property locked : Bool
+
+  property media : Nil
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property post_hint : String?
+
+  property preview : Preview?
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Nil
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : String?
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : String?
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32?
+
+  property thumbnail_width : Int32?
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : Variants
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Variants
+  include JSON::Serializable
+
+  property gif : Gif?
+
+  property mp4 : Gif?
+end
+
+class Gif
+  include JSON::Serializable
+
+  property resolutions : Array(Source)
+
+  property source : Source
+end
+
+alias Edited = Float64 | Bool
diff --git a/head/crystal/test/inputs/json/misc/2d4e2.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/2d4e2.json/default/TopLevel.cr
new file mode 100644
index 0000000..d33ecd2
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/2d4e2.json/default/TopLevel.cr
@@ -0,0 +1,123 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property objects : Array(ObjectElement)
+end
+
+class Meta
+  include JSON::Serializable
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
+
+class ObjectElement
+  include JSON::Serializable
+
+  property caucus : String?
+
+  property congress_numbers : Array(Int32)
+
+  property current : Bool
+
+  property description : String
+
+  property district : Nil
+
+  property enddate : String
+
+  property extra : Extra
+
+  property id : Int32
+
+  property leadership_title : String?
+
+  property party : String
+
+  property person : Person
+
+  property phone : String
+
+  property role_type : String
+
+  property role_type_label : String
+
+  property senator_class : String
+
+  property senator_class_label : String
+
+  property senator_rank : String
+
+  property senator_rank_label : String
+
+  property startdate : String
+
+  property state : String
+
+  property title : String
+
+  property title_long : String
+
+  property website : String
+end
+
+class Extra
+  include JSON::Serializable
+
+  property address : String
+
+  property contact_form : String
+
+  property fax : String?
+
+  property office : String
+
+  property rss_url : String?
+end
+
+class Person
+  include JSON::Serializable
+
+  property bioguideid : String
+
+  property birthday : String
+
+  property cspanid : Int32
+
+  property firstname : String
+
+  property gender : String
+
+  property gender_label : String
+
+  property id : Int32
+
+  property lastname : String
+
+  property link : String
+
+  property middlename : String
+
+  property name : String
+
+  property namemod : String
+
+  property nickname : String
+
+  property osid : String
+
+  property pvsid : String
+
+  property sortname : String
+
+  property twitterid : String?
+
+  property youtubeid : String?
+end
diff --git a/head/crystal/test/inputs/json/misc/2df80.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/2df80.json/default/TopLevel.cr
new file mode 100644
index 0000000..dd2a72b
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/2df80.json/default/TopLevel.cr
@@ -0,0 +1,53 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  property adminregion : Adminregion
+
+  @[JSON::Field(key: "capitalCity")]
+  property capital_city : String
+
+  property id : String
+
+  @[JSON::Field(key: "incomeLevel")]
+  property income_level : Adminregion
+
+  @[JSON::Field(key: "iso2Code")]
+  property iso2_code : String
+
+  property latitude : String
+
+  @[JSON::Field(key: "lendingType")]
+  property lending_type : Adminregion
+
+  property longitude : String
+
+  property name : String
+
+  property region : Adminregion
+end
+
+class Adminregion
+  include JSON::Serializable
+
+  property id : String
+
+  property value : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  property page : Int32
+
+  property pages : Int32
+
+  property per_page : String
+
+  property total : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/misc/31189.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/31189.json/default/TopLevel.cr
new file mode 100644
index 0000000..eaeca63
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/31189.json/default/TopLevel.cr
@@ -0,0 +1,47 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property details : String
+
+  property rates : Array(Rate)
+
+  property version : Nil
+end
+
+class Rate
+  include JSON::Serializable
+
+  property code : String
+
+  property country_code : String
+
+  property name : String
+
+  property periods : Array(Period)
+end
+
+class Period
+  include JSON::Serializable
+
+  property effective_from : String
+
+  property rates : Rates
+end
+
+class Rates
+  include JSON::Serializable
+
+  property parking : Float64?
+
+  property reduced : Float64?
+
+  property reduced1 : Float64?
+
+  property reduced2 : Float64?
+
+  property standard : Float64
+
+  property super_reduced : Float64?
+end
diff --git a/head/crystal/test/inputs/json/misc/32431.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/32431.json/default/TopLevel.cr
new file mode 100644
index 0000000..6ebe445
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/32431.json/default/TopLevel.cr
@@ -0,0 +1,110 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property bbox : Array(Float64)
+
+  property features : Array(Feature)
+
+  property metadata : Metadata
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Feature
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property feature_type : String
+
+  property geometry : Geometry
+
+  property id : String
+
+  property properties : Properties
+end
+
+class Geometry
+  include JSON::Serializable
+
+  property coordinates : Array(Float64)
+
+  @[JSON::Field(key: "type")]
+  property geometry_type : String
+end
+
+class Properties
+  include JSON::Serializable
+
+  property alert : Nil
+
+  property cdi : Nil
+
+  property code : String
+
+  property detail : String
+
+  property dmin : Float64?
+
+  property felt : Nil
+
+  property gap : Int32?
+
+  property ids : String
+
+  property mag : Float64
+
+  @[JSON::Field(key: "magType")]
+  property mag_type : String
+
+  property mmi : Nil
+
+  property net : String
+
+  property nst : Int32?
+
+  property place : String
+
+  @[JSON::Field(key: "type")]
+  property properties_type : String
+
+  property rms : Float64
+
+  property sig : Int32
+
+  property sources : String
+
+  property status : String
+
+  property time : Float64
+
+  property title : String
+
+  property tsunami : Int32
+
+  property types : String
+
+  property tz : Int32
+
+  property updated : Float64
+
+  property url : String
+end
+
+class Metadata
+  include JSON::Serializable
+
+  property api : String
+
+  property count : Int32
+
+  property generated : Float64
+
+  property status : Int32
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/32d5c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/32d5c.json/default/TopLevel.cr
new file mode 100644
index 0000000..6ef7d6e
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/32d5c.json/default/TopLevel.cr
@@ -0,0 +1,31 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: "BirthDate")]
+  property birth_date : String?
+
+  @[JSON::Field(key: "BirthDateIsProtected")]
+  property birth_date_is_protected : Bool
+
+  @[JSON::Field(key: "GenderTypeID")]
+  property gender_type_id : Int32
+
+  @[JSON::Field(key: "Notes")]
+  property notes : String
+
+  @[JSON::Field(key: "ParliamentaryName")]
+  property parliamentary_name : String
+
+  @[JSON::Field(key: "PersonID")]
+  property person_id : Int32
+
+  @[JSON::Field(key: "PhotoURL")]
+  property photo_url : String
+
+  @[JSON::Field(key: "PreferredName")]
+  property preferred_name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/337ed.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/337ed.json/default/TopLevel.cr
new file mode 100644
index 0000000..4a34ff2
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/337ed.json/default/TopLevel.cr
@@ -0,0 +1,116 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property cost_absolute : Int32?
+
+  property cost_max : Int32?
+
+  property cost_min : Int32?
+
+  property created_at : String
+
+  @[JSON::Field(key: "customIncomes")]
+  property custom_incomes : Array(CustomIncome)
+
+  property direct_rep_costs_max : Nil
+
+  property direct_rep_costs_min : Nil
+
+  property end_date : String
+
+  property eur_sources_grants : Int32
+
+  property eur_sources_grants_src : String?
+
+  property eur_sources_procurement : Int32
+
+  property eur_sources_procurement_src : String?
+
+  property id : String
+
+  property new_organisation : Nil
+
+  property no_clients : String?
+
+  property other_financial_information : String?
+
+  property other_sources_contributions : Int32?
+
+  property other_sources_donation : Int32?
+
+  property other_sources_total : Int32?
+
+  property public_financing_infranational : Int32?
+
+  property public_financing_national : Int32?
+
+  property public_financing_total : Int32?
+
+  property representative : String
+
+  @[JSON::Field(key: "type")]
+  property result_type : String
+
+  property start_date : String
+
+  property status : String
+
+  property total_budget : Int32?
+
+  property turnover_absolute : Int32?
+
+  property turnover_max : Int32?
+
+  property turnover_min : Int32?
+
+  property updated_at : String
+
+  property uri : String
+end
+
+class CustomIncome
+  include JSON::Serializable
+
+  property amount : Int32
+
+  property created_at : String
+
+  @[JSON::Field(key: "type")]
+  property custom_income_type : String
+
+  property id : String
+
+  property name : String
+
+  property status : String
+
+  property updated_at : String
+
+  property uri : String
+end
diff --git a/head/crystal/test/inputs/json/misc/33d2e.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/33d2e.json/default/TopLevel.cr
new file mode 100644
index 0000000..99f37ca
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/33d2e.json/default/TopLevel.cr
@@ -0,0 +1,72 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property laureates : Array(Laureate)
+end
+
+class Laureate
+  include JSON::Serializable
+
+  property born : String
+
+  @[JSON::Field(key: "bornCity")]
+  property born_city : String?
+
+  @[JSON::Field(key: "bornCountry")]
+  property born_country : String?
+
+  @[JSON::Field(key: "bornCountryCode")]
+  property born_country_code : String?
+
+  property died : String
+
+  @[JSON::Field(key: "diedCity")]
+  property died_city : String?
+
+  @[JSON::Field(key: "diedCountry")]
+  property died_country : String?
+
+  @[JSON::Field(key: "diedCountryCode")]
+  property died_country_code : String?
+
+  property firstname : String?
+
+  property gender : String
+
+  property id : String
+
+  property prizes : Array(Prize)
+
+  property surname : String?
+end
+
+class Prize
+  include JSON::Serializable
+
+  property affiliations : Array(AffiliationElement)
+
+  property category : String?
+
+  property motivation : String?
+
+  @[JSON::Field(key: "overallMotivation")]
+  property overall_motivation : String?
+
+  property share : String?
+
+  property year : String?
+end
+
+class AffiliationClass
+  include JSON::Serializable
+
+  property city : String?
+
+  property country : String?
+
+  property name : String?
+end
+
+alias AffiliationElement = AffiliationClass | Array(JSON::Any?)
diff --git a/head/crystal/test/inputs/json/misc/34702.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/34702.json/default/TopLevel.cr
new file mode 100644
index 0000000..be0ee39
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/34702.json/default/TopLevel.cr
@@ -0,0 +1,89 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property crs : Crs
+
+  property features : Array(Feature)
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+
+  @[JSON::Field(key: "totalFeatures")]
+  property total_features : Int32
+end
+
+class Crs
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property crs_type : String
+
+  property properties : CrsProperties
+end
+
+class CrsProperties
+  include JSON::Serializable
+
+  property name : String
+end
+
+class Feature
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property feature_type : String
+
+  property geometry : Geometry
+
+  property geometry_name : String
+
+  property id : String
+
+  property properties : FeatureProperties
+end
+
+class Geometry
+  include JSON::Serializable
+
+  property coordinates : Array(Float64)
+
+  @[JSON::Field(key: "type")]
+  property geometry_type : String
+end
+
+class FeatureProperties
+  include JSON::Serializable
+
+  property division : String
+
+  property fax : Float64
+
+  property fire_ban_r : String?
+
+  property latitude : Float64
+
+  property local_govt : String
+
+  property longitude : Float64
+
+  property no : String?
+
+  property phone : Float64
+
+  property postcode : Int32
+
+  @[JSON::Field(key: "type")]
+  property properties_type : String?
+
+  property psa : String
+
+  property region : String
+
+  property station : String
+
+  property street : String
+
+  property suburb : String
+end
diff --git a/head/crystal/test/inputs/json/misc/3536b.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/3536b.json/default/TopLevel.cr
new file mode 100644
index 0000000..2adb667
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/3536b.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : String
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/3659d.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/3659d.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/3659d.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/36d5d.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/36d5d.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/36d5d.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/3a6b3.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/3a6b3.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/3a6b3.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/3e9a3.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/3e9a3.json/default/TopLevel.cr
new file mode 100644
index 0000000..54f6724
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/3e9a3.json/default/TopLevel.cr
@@ -0,0 +1,53 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property message : Array(JSON::Any?)
+
+  @[JSON::Field(key: "responseTime")]
+  property response_time : Int32
+
+  @[JSON::Field(key: "Results")]
+  property results : Results
+
+  property status : String
+end
+
+class Results
+  include JSON::Serializable
+
+  property series : Array(Series)
+end
+
+class Series
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  @[JSON::Field(key: "seriesID")]
+  property series_id : String
+end
+
+class Datum
+  include JSON::Serializable
+
+  property footnotes : Array(Footnote)
+
+  property period : String
+
+  @[JSON::Field(key: "periodName")]
+  property period_name : String
+
+  property value : String
+
+  property year : String
+end
+
+class Footnote
+  include JSON::Serializable
+
+  property code : String?
+
+  property text : String?
+end
diff --git a/head/crystal/test/inputs/json/misc/3f1ce.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/3f1ce.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/3f1ce.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/421d4.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/421d4.json/default/TopLevel.cr
new file mode 100644
index 0000000..afe0e11
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/421d4.json/default/TopLevel.cr
@@ -0,0 +1,246 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum?))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  property attribution : String
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  property description : String
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property license : License
+
+  @[JSON::Field(key: "licenseId")]
+  property license_id : String
+
+  property locale : String
+
+  property metadata : Metadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowClass")]
+  property row_class : String
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  property tags : Array(String)
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Query
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property average : String?
+
+  property largest : String?
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String?
+
+  property sum : String?
+
+  property top : Array(Top)?
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Query
+  include JSON::Serializable
+
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class License
+  include JSON::Serializable
+
+  property name : String
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  @[JSON::Field(key: "rdfClass")]
+  property rdf_class : String
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+
+  @[JSON::Field(key: "rowIdentifier")]
+  property row_identifier : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/437e7.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/437e7.json/default/TopLevel.cr
new file mode 100644
index 0000000..b3db45e
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/437e7.json/default/TopLevel.cr
@@ -0,0 +1,190 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/43970.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/43970.json/default/TopLevel.cr
new file mode 100644
index 0000000..fb78e63
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/43970.json/default/TopLevel.cr
@@ -0,0 +1,16 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: "ID")]
+  property id : Int32
+
+  @[JSON::Field(key: "Name")]
+  property name : String
+
+  @[JSON::Field(key: "Notes")]
+  property notes : String
+end
diff --git a/head/crystal/test/inputs/json/misc/43eaf.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/43eaf.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/43eaf.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/458db.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/458db.json/default/TopLevel.cr
new file mode 100644
index 0000000..744e08e
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/458db.json/default/TopLevel.cr
@@ -0,0 +1,78 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property metadata : Metadata
+
+  property results : Array(Result)
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "executionTime")]
+  property execution_time : Float64
+
+  @[JSON::Field(key: "responseInfo")]
+  property response_info : ResponseInfo
+
+  property resultset : Resultset
+end
+
+class ResponseInfo
+  include JSON::Serializable
+
+  @[JSON::Field(key: "developerMessage")]
+  property developer_message : String
+
+  property status : Int32
+end
+
+class Resultset
+  include JSON::Serializable
+
+  property count : Int32
+
+  property page : Int32
+
+  property pagesize : Int32
+end
+
+class Result
+  include JSON::Serializable
+
+  property attachments : Array(JSON::Any?)
+
+  property body : String
+
+  property changed : String
+
+  property component : Array(Component)
+
+  property created : String
+
+  property date : String
+
+  property image : Array(JSON::Any?)
+
+  property teaser : Array(JSON::Any?)
+
+  property title : String
+
+  property topic : Array(JSON::Any?)
+
+  property url : String
+
+  property uuid : String
+
+  property vuuid : String
+end
+
+class Component
+  include JSON::Serializable
+
+  property name : String
+
+  property uuid : String
+end
diff --git a/head/crystal/test/inputs/json/misc/4961a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/4961a.json/default/TopLevel.cr
new file mode 100644
index 0000000..117eadd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/4961a.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Float64
+end
diff --git a/head/crystal/test/inputs/json/misc/4a0d7.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/4a0d7.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/4a0d7.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/4a455.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/4a455.json/default/TopLevel.cr
new file mode 100644
index 0000000..b1eb97b
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/4a455.json/default/TopLevel.cr
@@ -0,0 +1,70 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property crs : Crs
+
+  property features : Array(Feature)
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+
+  @[JSON::Field(key: "totalFeatures")]
+  property total_features : Int32
+end
+
+class Crs
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property crs_type : String
+
+  property properties : CrsProperties
+end
+
+class CrsProperties
+  include JSON::Serializable
+
+  property name : String
+end
+
+class Feature
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property feature_type : String
+
+  property geometry : Geometry
+
+  property geometry_name : String
+
+  property id : String
+
+  property properties : FeatureProperties
+end
+
+class Geometry
+  include JSON::Serializable
+
+  property coordinates : Array(Array(Float64))
+
+  @[JSON::Field(key: "type")]
+  property geometry_type : String
+end
+
+class FeatureProperties
+  include JSON::Serializable
+
+  property facebookaccount : String
+
+  property frequencyfinderurl : String
+
+  property name : String
+
+  property siteurl : String
+
+  property streetaddress : String
+
+  property twitteraccount : String
+end
diff --git a/head/crystal/test/inputs/json/misc/4c547.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/4c547.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/4c547.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/4d6fb.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/4d6fb.json/default/TopLevel.cr
new file mode 100644
index 0000000..f94b063
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/4d6fb.json/default/TopLevel.cr
@@ -0,0 +1,248 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : Nil
+
+  property author_flair_text : Nil
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : Nil
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : Nil
+
+  property link_flair_text : Nil
+
+  property locked : Bool
+
+  property media : Media?
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property post_hint : String?
+
+  property preview : Preview?
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Media?
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : Nil
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : Nil
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32?
+
+  property thumbnail_width : Int32?
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class Media
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property media_type : String
+
+  property oembed : Oembed
+end
+
+class Oembed
+  include JSON::Serializable
+
+  property author_name : String
+
+  property author_url : String
+
+  property height : Int32
+
+  property html : String
+
+  @[JSON::Field(key: "type")]
+  property oembed_type : String
+
+  property provider_name : String
+
+  property provider_url : String
+
+  property thumbnail_height : Int32
+
+  property thumbnail_url : String
+
+  property thumbnail_width : Int32
+
+  property title : String
+
+  property version : String
+
+  property width : Int32
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+  property content : String?
+
+  property height : Int32?
+
+  property scrolling : Bool?
+
+  property width : Int32?
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : Variants
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Variants
+  include JSON::Serializable
+
+end
diff --git a/head/crystal/test/inputs/json/misc/4e336.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/4e336.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/4e336.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/54147.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/54147.json/default/TopLevel.cr
new file mode 100644
index 0000000..948480f
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/54147.json/default/TopLevel.cr
@@ -0,0 +1,40 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property args : Args
+
+  property data : String
+
+  property files : Args
+
+  property form : Args
+
+  property headers : Headers
+
+  property origin : String
+
+  property url : String
+end
+
+class Args
+  include JSON::Serializable
+
+end
+
+class Headers
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Accept-Encoding")]
+  property accept_encoding : String
+
+  @[JSON::Field(key: "Connection")]
+  property connection : String
+
+  @[JSON::Field(key: "Host")]
+  property host : String
+
+  @[JSON::Field(key: "User-Agent")]
+  property user_agent : String
+end
diff --git a/head/crystal/test/inputs/json/misc/54d32.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/54d32.json/default/TopLevel.cr
new file mode 100644
index 0000000..c7bd2d7
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/54d32.json/default/TopLevel.cr
@@ -0,0 +1,41 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property created_at : String
+
+  property id : String
+
+  property person_id : String
+
+  property representative_id : String
+
+  property status : String
+
+  property updated_at : String
+end
diff --git a/head/crystal/test/inputs/json/misc/570ec.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/570ec.json/default/TopLevel.cr
new file mode 100644
index 0000000..05c134e
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/570ec.json/default/TopLevel.cr
@@ -0,0 +1,57 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(OtherName)
+
+  property superseded_by : Nil
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class OtherName
+  include JSON::Serializable
+
+  property name : String
+
+  property note : String?
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/5dd0d.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/5dd0d.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/5dd0d.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/5eae5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/5eae5.json/default/TopLevel.cr
new file mode 100644
index 0000000..a09600d
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/5eae5.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Date")]
+  property date : String
+
+  @[JSON::Field(key: "ID")]
+  property id : Int32
+
+  @[JSON::Field(key: "Sponsor")]
+  property sponsor : String
+
+  @[JSON::Field(key: "Title")]
+  property title : String
+end
diff --git a/head/crystal/test/inputs/json/misc/5eb20.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/5eb20.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/5eb20.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/5f3a1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/5f3a1.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/5f3a1.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/5f7fe.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/5f7fe.json/default/TopLevel.cr
new file mode 100644
index 0000000..e98a41a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/5f7fe.json/default/TopLevel.cr
@@ -0,0 +1,390 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum?))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  property attribution : String
+
+  @[JSON::Field(key: "attributionLink")]
+  property attribution_link : String
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  property description : String
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property locale : String
+
+  property metadata : Metadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  property tags : Array(String)
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Format
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property largest : String
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String
+
+  property top : Array(Top)
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Format
+  include JSON::Serializable
+
+  property align : String?
+
+  property view : String?
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class Metadata
+  include JSON::Serializable
+
+  property attachments : Array(Attachment)
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  property custom_fields : CustomFields
+
+  @[JSON::Field(key: "jsonQuery")]
+  property json_query : JsonQuery
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+end
+
+class Attachment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "assetId")]
+  property asset_id : String
+
+  @[JSON::Field(key: "blobId")]
+  property blob_id : String
+
+  property filename : String
+
+  property name : String
+end
+
+class CustomFields
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Additional Resources")]
+  property additional_resources : AdditionalResources
+
+  @[JSON::Field(key: "Common Core")]
+  property common_core : CommonCore
+
+  @[JSON::Field(key: "Dataset Information")]
+  property dataset_information : DatasetInformation
+
+  @[JSON::Field(key: "Dataset Summary")]
+  property dataset_summary : DatasetSummary
+
+  @[JSON::Field(key: "Notes")]
+  property notes : Notes
+end
+
+class AdditionalResources
+  include JSON::Serializable
+
+  @[JSON::Field(key: "See Also ")]
+  property additional_resources_see_also : String
+
+  @[JSON::Field(key: "See Also")]
+  property see_also : String
+end
+
+class CommonCore
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Email")]
+  property contact_email : String
+
+  @[JSON::Field(key: "Contact Name")]
+  property contact_name : String
+
+  @[JSON::Field(key: "Publisher")]
+  property publisher : String
+end
+
+class DatasetInformation
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Agency")]
+  property agency : String
+end
+
+class DatasetSummary
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Information")]
+  property contact_information : String
+
+  @[JSON::Field(key: "Coverage")]
+  property coverage : String
+
+  @[JSON::Field(key: "Data Frequency")]
+  property data_frequency : String
+
+  @[JSON::Field(key: "Dataset Owner")]
+  property dataset_owner : String
+
+  @[JSON::Field(key: "Granularity")]
+  property granularity : String
+
+  @[JSON::Field(key: "Organization")]
+  property organization : String
+
+  @[JSON::Field(key: "Posting Frequency")]
+  property posting_frequency : String
+
+  @[JSON::Field(key: "Time Period")]
+  property time_period : String
+
+  @[JSON::Field(key: "Units")]
+  property units : String
+end
+
+class Notes
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Notes")]
+  property notes : String
+end
+
+class JsonQuery
+  include JSON::Serializable
+
+  property order : Array(Order)
+end
+
+class Order
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "profileImageUrlLarge")]
+  property profile_image_url_large : String
+
+  @[JSON::Field(key: "profileImageUrlMedium")]
+  property profile_image_url_medium : String
+
+  @[JSON::Field(key: "profileImageUrlSmall")]
+  property profile_image_url_small : String
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "roleName")]
+  property role_name : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+class Query
+  include JSON::Serializable
+
+  @[JSON::Field(key: "orderBys")]
+  property order_bys : Array(OrderBy)
+end
+
+class OrderBy
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  property expression : Expression
+end
+
+class Expression
+  include JSON::Serializable
+
+  @[JSON::Field(key: "columnId")]
+  property column_id : Int32
+
+  @[JSON::Field(key: "type")]
+  property expression_type : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/617e8.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/617e8.json/default/TopLevel.cr
new file mode 100644
index 0000000..d71cfcd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/617e8.json/default/TopLevel.cr
@@ -0,0 +1,386 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum?))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  property attribution : String
+
+  @[JSON::Field(key: "attributionLink")]
+  property attribution_link : String
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  property description : String
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property locale : String
+
+  property metadata : Metadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  property tags : Array(String)
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  property description : String?
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Format
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property largest : String
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String
+
+  property top : Array(Top)
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Format
+  include JSON::Serializable
+
+  property align : String?
+
+  property view : String?
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class Metadata
+  include JSON::Serializable
+
+  property attachments : Array(Attachment)
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  property custom_fields : CustomFields
+
+  @[JSON::Field(key: "jsonQuery")]
+  property json_query : JsonQuery
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+end
+
+class Attachment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "assetId")]
+  property asset_id : String
+
+  @[JSON::Field(key: "blobId")]
+  property blob_id : String
+
+  property filename : String
+
+  property name : String
+end
+
+class CustomFields
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Additional Resources")]
+  property additional_resources : AdditionalResources
+
+  @[JSON::Field(key: "Common Core")]
+  property common_core : CommonCore
+
+  @[JSON::Field(key: "Dataset Information")]
+  property dataset_information : DatasetInformation
+
+  @[JSON::Field(key: "Dataset Summary")]
+  property dataset_summary : DatasetSummary
+
+  @[JSON::Field(key: "Notes")]
+  property notes : Notes
+end
+
+class AdditionalResources
+  include JSON::Serializable
+
+  @[JSON::Field(key: "See Also")]
+  property see_also : String
+end
+
+class CommonCore
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Email")]
+  property contact_email : String
+
+  @[JSON::Field(key: "Contact Name")]
+  property contact_name : String
+
+  @[JSON::Field(key: "Publisher")]
+  property publisher : String
+end
+
+class DatasetInformation
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Agency")]
+  property agency : String
+end
+
+class DatasetSummary
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Information")]
+  property contact_information : String
+
+  @[JSON::Field(key: "Coverage")]
+  property coverage : String
+
+  @[JSON::Field(key: "Data Frequency")]
+  property data_frequency : String
+
+  @[JSON::Field(key: "Dataset Owner")]
+  property dataset_owner : String
+
+  @[JSON::Field(key: "Granularity")]
+  property granularity : String
+
+  @[JSON::Field(key: "Organization")]
+  property organization : String
+
+  @[JSON::Field(key: "Posting Frequency")]
+  property posting_frequency : String
+
+  @[JSON::Field(key: "Time Period")]
+  property time_period : String
+end
+
+class Notes
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Notes")]
+  property notes : String
+end
+
+class JsonQuery
+  include JSON::Serializable
+
+  property order : Array(Order)
+end
+
+class Order
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "profileImageUrlLarge")]
+  property profile_image_url_large : String
+
+  @[JSON::Field(key: "profileImageUrlMedium")]
+  property profile_image_url_medium : String
+
+  @[JSON::Field(key: "profileImageUrlSmall")]
+  property profile_image_url_small : String
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "roleName")]
+  property role_name : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+class Query
+  include JSON::Serializable
+
+  @[JSON::Field(key: "orderBys")]
+  property order_bys : Array(OrderBy)
+end
+
+class OrderBy
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  property expression : Expression
+end
+
+class Expression
+  include JSON::Serializable
+
+  @[JSON::Field(key: "columnId")]
+  property column_id : Int32
+
+  @[JSON::Field(key: "type")]
+  property expression_type : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/61b66.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/61b66.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/61b66.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/6260a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/6260a.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/6260a.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/65dec.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/65dec.json/default/TopLevel.cr
new file mode 100644
index 0000000..37b085f
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/65dec.json/default/TopLevel.cr
@@ -0,0 +1,114 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property booster : Array(String)
+
+  property border : String
+
+  property cards : Array(Card)
+
+  property code : String
+
+  @[JSON::Field(key: "gathererCode")]
+  property gatherer_code : String
+
+  @[JSON::Field(key: "magicCardsInfoCode")]
+  property magic_cards_info_code : String
+
+  property mkm_id : Int32
+
+  property mkm_name : String
+
+  property name : String
+
+  @[JSON::Field(key: "releaseDate")]
+  property release_date : String
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Card
+  include JSON::Serializable
+
+  property artist : String
+
+  @[JSON::Field(key: "type")]
+  property card_type : String
+
+  property cmc : Int32
+
+  @[JSON::Field(key: "colorIdentity")]
+  property color_identity : Array(String)?
+
+  property colors : Array(String)?
+
+  property flavor : String?
+
+  property id : String
+
+  @[JSON::Field(key: "imageName")]
+  property image_name : String
+
+  property layout : String
+
+  property legalities : Array(LegalityElement)
+
+  @[JSON::Field(key: "manaCost")]
+  property mana_cost : String?
+
+  @[JSON::Field(key: "mciNumber")]
+  property mci_number : String?
+
+  property multiverseid : Int32
+
+  property name : String
+
+  @[JSON::Field(key: "originalText")]
+  property original_text : String
+
+  @[JSON::Field(key: "originalType")]
+  property original_type : String
+
+  property power : String?
+
+  property printings : Array(String)
+
+  property rarity : String
+
+  property reserved : Bool?
+
+  property rulings : Array(Ruling)?
+
+  property subtypes : Array(String)?
+
+  property supertypes : Array(String)?
+
+  property text : String?
+
+  property toughness : String?
+
+  property types : Array(String)
+
+  property variations : Array(Int32)?
+
+  property watermark : String?
+end
+
+class LegalityElement
+  include JSON::Serializable
+
+  property format : String
+
+  property legality : String
+end
+
+class Ruling
+  include JSON::Serializable
+
+  property date : String
+
+  property text : String
+end
diff --git a/head/crystal/test/inputs/json/misc/66121.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/66121.json/default/TopLevel.cr
new file mode 100644
index 0000000..a9162f1
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/66121.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : String?
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/6617c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/6617c.json/default/TopLevel.cr
new file mode 100644
index 0000000..6d78e68
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/6617c.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property iss_position : IssPosition
+
+  property message : String
+
+  property timestamp : Int32
+end
+
+class IssPosition
+  include JSON::Serializable
+
+  property latitude : String
+
+  property longitude : String
+end
diff --git a/head/crystal/test/inputs/json/misc/67c03.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/67c03.json/default/TopLevel.cr
new file mode 100644
index 0000000..af9f048
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/67c03.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property message : String
+
+  property number : Int32
+
+  property people : Array(Person)
+end
+
+class Person
+  include JSON::Serializable
+
+  property craft : String
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/68c30.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/68c30.json/default/TopLevel.cr
new file mode 100644
index 0000000..2926e74
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/68c30.json/default/TopLevel.cr
@@ -0,0 +1,65 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property txs : Array(Tx)
+end
+
+class Tx
+  include JSON::Serializable
+
+  property double_spend : Bool
+
+  property hash : String
+
+  property inputs : Array(Input)
+
+  property lock_time : Int32
+
+  property relayed_by : String
+
+  property size : Int32
+
+  property time : Int32
+
+  property tx_index : Int32
+
+  @[JSON::Field(key: "out")]
+  property tx_out : Array(Out)
+
+  property ver : Int32
+
+  property vin_sz : Int32
+
+  property vout_sz : Int32
+end
+
+class Input
+  include JSON::Serializable
+
+  property prev_out : Out
+
+  property script : String
+
+  property sequence : Float64
+end
+
+class Out
+  include JSON::Serializable
+
+  property addr : String
+
+  property n : Int32
+
+  @[JSON::Field(key: "type")]
+  property out_type : Int32
+
+  property script : String
+
+  property spent : Bool
+
+  property tx_index : Int32
+
+  property value : Float64
+end
diff --git a/head/crystal/test/inputs/json/misc/6c155.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/6c155.json/default/TopLevel.cr
new file mode 100644
index 0000000..83eb74a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/6c155.json/default/TopLevel.cr
@@ -0,0 +1,104 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property metadata : Metadata
+
+  property results : Array(Result)
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "executionTime")]
+  property execution_time : Float64
+
+  @[JSON::Field(key: "responseInfo")]
+  property response_info : ResponseInfo
+
+  property resultset : Resultset
+end
+
+class ResponseInfo
+  include JSON::Serializable
+
+  @[JSON::Field(key: "developerMessage")]
+  property developer_message : String
+
+  property status : Int32
+end
+
+class Resultset
+  include JSON::Serializable
+
+  property count : Int32
+
+  property page : Int32
+
+  property pagesize : Int32
+end
+
+class Result
+  include JSON::Serializable
+
+  property attachment : Array(JSON::Any?)
+
+  property body : String
+
+  property changed : String
+
+  property component : Array(Component)
+
+  property created : String
+
+  property date : String
+
+  property image : Array(JSON::Any?)
+
+  property location : Location
+
+  property teaser : Nil
+
+  property title : String
+
+  property topic : Array(JSON::Any?)
+
+  property url : String
+
+  property uuid : String
+
+  property vuuid : String
+end
+
+class Component
+  include JSON::Serializable
+
+  property name : String
+
+  property uuid : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property administrative_area : String
+
+  property country : String
+
+  property fax_number : String
+
+  property locality : String
+
+  property mobile_number : String
+
+  property phone_number : String
+
+  property phone_number_extension : String
+
+  property postal_code : String
+
+  property sub_premise : Nil
+
+  property thoroughfare : String
+end
diff --git a/head/crystal/test/inputs/json/misc/6de06.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/6de06.json/default/TopLevel.cr
new file mode 100644
index 0000000..af0dc0e
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/6de06.json/default/TopLevel.cr
@@ -0,0 +1,261 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : String?
+
+  property author_flair_text : String?
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : Nil
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : String?
+
+  property link_flair_text : String?
+
+  property locked : Bool
+
+  property media : Media?
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property post_hint : String?
+
+  property preview : Preview?
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Media?
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : String?
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : String?
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32?
+
+  property thumbnail_width : Int32?
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class Media
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property media_type : String
+
+  property oembed : Oembed
+end
+
+class Oembed
+  include JSON::Serializable
+
+  property description : String
+
+  property height : Int32
+
+  property html : String
+
+  @[JSON::Field(key: "type")]
+  property oembed_type : String
+
+  property provider_name : String
+
+  property provider_url : String
+
+  property thumbnail_height : Int32
+
+  property thumbnail_url : String
+
+  property thumbnail_width : Int32
+
+  property title : String
+
+  property version : String
+
+  property width : Int32
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+  property content : String?
+
+  property height : Int32?
+
+  property scrolling : Bool?
+
+  property width : Int32?
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : Variants
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Variants
+  include JSON::Serializable
+
+  property gif : Gif?
+
+  property mp4 : Gif?
+
+  property nsfw : Gif?
+
+  property obfuscated : Gif?
+end
+
+class Gif
+  include JSON::Serializable
+
+  property resolutions : Array(Source)
+
+  property source : Source
+end
diff --git a/head/crystal/test/inputs/json/misc/6dec6.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/6dec6.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/6dec6.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/6eb00.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/6eb00.json/default/TopLevel.cr
new file mode 100644
index 0000000..2f99e18
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/6eb00.json/default/TopLevel.cr
@@ -0,0 +1,16 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: "DirectorateID")]
+  property directorate_id : Int32
+
+  @[JSON::Field(key: "Id")]
+  property id : Int32
+
+  @[JSON::Field(key: "Name")]
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/70c77.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/70c77.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/70c77.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/734ad.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/734ad.json/default/TopLevel.cr
new file mode 100644
index 0000000..b103ca3
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/734ad.json/default/TopLevel.cr
@@ -0,0 +1,145 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property acronym : String?
+
+  property activity_consult_committees : String
+
+  property activity_eu_legislative : String
+
+  property activity_expert_groups : String
+
+  property activity_high_level_groups : String
+
+  property activity_industry_forums : String
+
+  property activity_inter_groups : String
+
+  property activity_other : String?
+
+  property activity_relevant_comm : String
+
+  property be_office_country : String?
+
+  property be_office_lat : Float64?
+
+  property be_office_lon : Float64?
+
+  property be_office_phone : String?
+
+  property be_office_post_code : String?
+
+  property be_office_postbox : String?
+
+  property be_office_street : String?
+
+  property be_office_town : String?
+
+  property code_of_conduct : String
+
+  property contact_country : Int32
+
+  property created_at : String
+
+  property entity : String
+
+  property goals : String
+
+  property head : String
+
+  property head_office_country : String
+
+  property head_office_lat : Float64?
+
+  property head_office_lon : Float64?
+
+  property head_office_phone : String
+
+  property head_office_post_code : String?
+
+  property head_office_postbox : String?
+
+  property head_office_street : String
+
+  property head_office_town : String
+
+  property id : String
+
+  property identification_code : String
+
+  property info_members : String
+
+  property last_update_date : String
+
+  property legal : String
+
+  property legal_status : String
+
+  property main_category : Int32
+
+  property main_category_title : String
+
+  property members : Int32
+
+  property members_100 : Int32?
+
+  property members_25 : Int32?
+
+  property members_50 : Int32?
+
+  property members_75 : Int32?
+
+  property members_fte : Float64
+
+  property name : String
+
+  property native_name : Nil
+
+  property networking : String?
+
+  property number_of_natural_persons : Int32?
+
+  property other_code_of_conduct : String?
+
+  property registration_date : String
+
+  property status : String
+
+  property structure_members : String
+
+  property sub_category : Int32
+
+  property sub_category_title : String
+
+  property updated_at : String
+
+  property uri : String
+
+  property web_site_url : String?
+end
diff --git a/head/crystal/test/inputs/json/misc/75912.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/75912.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/75912.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/7681c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7681c.json/default/TopLevel.cr
new file mode 100644
index 0000000..5d22178
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7681c.json/default/TopLevel.cr
@@ -0,0 +1,195 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+
+  @[JSON::Field(key: "480w_still")]
+  property the_480_w_still : Downsized?
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String?
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/76ae1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/76ae1.json/default/TopLevel.cr
new file mode 100644
index 0000000..120b306
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/76ae1.json/default/TopLevel.cr
@@ -0,0 +1,344 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "basePath")]
+  property base_path : String
+
+  property definitions : Definitions
+
+  property host : String
+
+  property info : Info
+
+  property paths : Paths
+
+  property produces : Array(String)
+
+  property schemes : Array(String)
+
+  property swagger : String
+end
+
+class Definitions
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Article")]
+  property article : Article
+
+  @[JSON::Field(key: "Center")]
+  property center : Article
+
+  @[JSON::Field(key: "DeMinimis")]
+  property de_minimis : DeMinimis
+
+  @[JSON::Field(key: "Event")]
+  property event : Article
+
+  @[JSON::Field(key: "FAQ")]
+  property faq : Faq
+
+  @[JSON::Field(key: "Lead")]
+  property lead : Article
+
+  @[JSON::Field(key: "List")]
+  property list : Article
+
+  @[JSON::Field(key: "MarketIntelligence")]
+  property market_intelligence : Article
+
+  @[JSON::Field(key: "Office")]
+  property office : Article
+
+  @[JSON::Field(key: "Provider")]
+  property provider : Article
+
+  @[JSON::Field(key: "Rate")]
+  property rate : Article
+
+  @[JSON::Field(key: "Report")]
+  property report : Report
+
+  @[JSON::Field(key: "Taxonomy")]
+  property taxonomy : Taxonomy
+end
+
+class Article
+  include JSON::Serializable
+
+  property properties : Hash(String, Property)
+end
+
+class Property
+  include JSON::Serializable
+
+  property description : String
+
+  @[JSON::Field(key: "type")]
+  property property_type : String
+end
+
+class DeMinimis
+  include JSON::Serializable
+
+  property properties : DeMinimisProperties
+end
+
+class DeMinimisProperties
+  include JSON::Serializable
+
+  property countries : Property
+
+  property country : Property
+
+  property de_minimis_currency : Property
+
+  property de_minimis_value : Property
+
+  property notes : Property
+
+  property vat_amount : Property
+
+  property vat_currency : Property
+end
+
+class Faq
+  include JSON::Serializable
+
+  property properties : FaqProperties
+end
+
+class FaqProperties
+  include JSON::Serializable
+
+  property answer : Property
+
+  property countries : Property
+
+  property first_published_date : Property
+
+  property id : Property
+
+  property industries : Property
+
+  property last_published_date : Property
+
+  property question : Property
+
+  property topics : Property
+
+  property trade_regions : Property
+
+  property url : Property
+
+  property world_regions : Property
+end
+
+class Report
+  include JSON::Serializable
+
+  property properties : ReportProperties
+end
+
+class ReportProperties
+  include JSON::Serializable
+
+  property countries : Property
+
+  property description : Property
+
+  property expiration_date : Property
+
+  property id : Property
+
+  property industries : Property
+
+  property ita_industries : Property
+
+  property report_type : Property
+
+  property title : Property
+
+  property url : Property
+end
+
+class Taxonomy
+  include JSON::Serializable
+
+  property properties : TaxonomyProperties
+end
+
+class TaxonomyProperties
+  include JSON::Serializable
+
+  property annotations : Property
+
+  property datatype_properties : Property
+
+  property id : Property
+
+  property label : Property
+
+  @[JSON::Field(key: "type")]
+  property properties_type : Property
+
+  property sub_class_of : Property
+end
+
+class Info
+  include JSON::Serializable
+
+  property description : String
+
+  property title : String
+
+  property version : String
+end
+
+class Paths
+  include JSON::Serializable
+
+  @[JSON::Field(key: "/business_service_providers/search")]
+  property business_service_providers_search : BusinessServiceProvidersSearchClass
+
+  @[JSON::Field(key: "/consolidated_screening_list/search")]
+  property consolidated_screening_list_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/de_minimis/search")]
+  property de_minimis_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/ita_faqs/search")]
+  property ita_faqs_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/ita_office_locations/search")]
+  property ita_office_locations_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/ita_taxonomies/search")]
+  property ita_taxonomies_search : BusinessServiceProvidersSearchClass
+
+  @[JSON::Field(key: "/ita_zipcode_to_post/search")]
+  property ita_zipcode_to_post_search : BusinessServiceProvidersSearchClass
+
+  @[JSON::Field(key: "/market_intelligence/search")]
+  property market_intelligence_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/market_research_library/search")]
+  property market_research_library_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/tariff_rates/search")]
+  property tariff_rates_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/trade_articles/search")]
+  property trade_articles_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/trade_events/search")]
+  property trade_events_search : ConsolidatedScreeningListSearchClass
+
+  @[JSON::Field(key: "/trade_leads/search")]
+  property trade_leads_search : ConsolidatedScreeningListSearchClass
+end
+
+class BusinessServiceProvidersSearchClass
+  include JSON::Serializable
+
+  property get : BusinessServiceProvidersSearchGet
+end
+
+class BusinessServiceProvidersSearchGet
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : PurpleResponses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class Parameter
+  include JSON::Serializable
+
+  property description : String
+
+  property format : String
+
+  property name : String
+
+  @[JSON::Field(key: "in")]
+  property parameter_in : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : String
+
+  property required : Bool
+end
+
+class PurpleResponses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : Purple200
+end
+
+class Purple200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : ItemsClass
+end
+
+class ItemsClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "$ref")]
+  property ref : String
+end
+
+class ConsolidatedScreeningListSearchClass
+  include JSON::Serializable
+
+  property get : ConsolidatedScreeningListSearchGet
+end
+
+class ConsolidatedScreeningListSearchGet
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : FluffyResponses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class FluffyResponses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : Fluffy200
+end
+
+class Fluffy200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : PurpleSchema
+end
+
+class PurpleSchema
+  include JSON::Serializable
+
+  property items : ItemsClass
+
+  @[JSON::Field(key: "type")]
+  property schema_type : String
+end
diff --git a/head/crystal/test/inputs/json/misc/77392.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/77392.json/default/TopLevel.cr
new file mode 100644
index 0000000..0cbe7bb
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/77392.json/default/TopLevel.cr
@@ -0,0 +1,27 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property designation : String
+
+  property discovery_date : String
+
+  property h_mag : String?
+
+  property i_deg : String
+
+  property moid_au : String
+
+  property orbit_class : String
+
+  property period_yr : String?
+
+  property pha : String
+
+  property q_au_1 : String
+
+  property q_au_2 : String?
+end
diff --git a/head/crystal/test/inputs/json/misc/7d397.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7d397.json/default/TopLevel.cr
new file mode 100644
index 0000000..38979ce
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7d397.json/default/TopLevel.cr
@@ -0,0 +1,130 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "basePath")]
+  property base_path : String
+
+  property definitions : Definitions
+
+  property host : String
+
+  property info : Info
+
+  property paths : Paths
+
+  property produces : Array(String)
+
+  property schemes : Array(String)
+
+  property swagger : String
+end
+
+class Definitions
+  include JSON::Serializable
+
+  @[JSON::Field(key: "List")]
+  property list : List
+end
+
+class List
+  include JSON::Serializable
+
+  property properties : Hash(String, Property)
+end
+
+class Property
+  include JSON::Serializable
+
+  property description : String
+
+  @[JSON::Field(key: "type")]
+  property property_type : String
+end
+
+class Info
+  include JSON::Serializable
+
+  property description : String
+
+  property title : String
+
+  property version : String
+end
+
+class Paths
+  include JSON::Serializable
+
+  @[JSON::Field(key: "/consolidated_screening_list/search")]
+  property consolidated_screening_list_search : ConsolidatedScreeningListSearch
+end
+
+class ConsolidatedScreeningListSearch
+  include JSON::Serializable
+
+  property get : Get
+end
+
+class Get
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : Responses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class Parameter
+  include JSON::Serializable
+
+  property description : String
+
+  property format : String
+
+  property name : String
+
+  @[JSON::Field(key: "in")]
+  property parameter_in : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : String
+
+  property required : Bool
+end
+
+class Responses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : The200
+end
+
+class The200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : Schema
+end
+
+class Schema
+  include JSON::Serializable
+
+  property items : Items
+
+  @[JSON::Field(key: "type")]
+  property schema_type : String
+end
+
+class Items
+  include JSON::Serializable
+
+  @[JSON::Field(key: "$ref")]
+  property ref : String
+end
diff --git a/head/crystal/test/inputs/json/misc/7d722.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7d722.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7d722.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/7df41.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7df41.json/default/TopLevel.cr
new file mode 100644
index 0000000..3466f8f
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7df41.json/default/TopLevel.cr
@@ -0,0 +1,25 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property pc : Pc
+
+  property ps3 : Pc
+
+  property ps4 : Pc
+
+  property xbox : Pc
+
+  property xone : Pc
+end
+
+class Pc
+  include JSON::Serializable
+
+  property count : Int32
+
+  property label : String
+
+  property peak24 : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/7dfa6.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7dfa6.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7dfa6.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/7eb30.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7eb30.json/default/TopLevel.cr
new file mode 100644
index 0000000..0a8e444
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7eb30.json/default/TopLevel.cr
@@ -0,0 +1,58 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property previous : Nil
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Result
+  include JSON::Serializable
+
+  property code : String
+
+  property english : String
+
+  property fav : Bool
+
+  property group : Group
+
+  property location : String
+
+  property min_screens : Int32
+
+  property num_views : Int32
+
+  property showtimes : String
+
+  property stars : Int32
+
+  property tel : String
+
+  property thai : String
+
+  property today_screens : Int32
+
+  property url : String
+
+  property website : String
+end
+
+class Group
+  include JSON::Serializable
+
+  property code : String
+
+  property english : String
+
+  property thai : String
+
+  property website : String
+end
diff --git a/head/crystal/test/inputs/json/misc/7f568.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7f568.json/default/TopLevel.cr
new file mode 100644
index 0000000..fda80c1
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7f568.json/default/TopLevel.cr
@@ -0,0 +1,54 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property comments : Int32
+
+  property comments_url : String
+
+  property commits_url : String
+
+  property created_at : String
+
+  property description : String?
+
+  property files : Hash(String, FileValue)
+
+  property forks_url : String
+
+  property git_pull_url : String
+
+  property git_push_url : String
+
+  property html_url : String
+
+  property id : String
+
+  property public : Bool
+
+  property truncated : Bool
+
+  property updated_at : String
+
+  property url : String
+
+  property user : Nil
+end
+
+class FileValue
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property file_type : String
+
+  property filename : String
+
+  property language : String?
+
+  property raw_url : String
+
+  property size : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/7fbfb.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/7fbfb.json/default/TopLevel.cr
new file mode 100644
index 0000000..4b9cdae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/7fbfb.json/default/TopLevel.cr
@@ -0,0 +1,39 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  property country : Country
+
+  property date : String
+
+  property decimal : String
+
+  property indicator : Country
+
+  property value : String
+end
+
+class Country
+  include JSON::Serializable
+
+  property id : String
+
+  property value : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  property page : Int32
+
+  property pages : Int32
+
+  property per_page : String
+
+  property total : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/misc/80aff.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/80aff.json/default/TopLevel.cr
new file mode 100644
index 0000000..8ee8d53
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/80aff.json/default/TopLevel.cr
@@ -0,0 +1,43 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : Bool
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property created_at : String
+
+  property id : Int32
+
+  property items : Int32
+
+  property name : String
+
+  property parent : Int32?
+
+  property updated_at : String
+
+  property uri : String
+end
diff --git a/head/crystal/test/inputs/json/misc/82509.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/82509.json/default/TopLevel.cr
new file mode 100644
index 0000000..7a83695
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/82509.json/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property origin : String
+end
diff --git a/head/crystal/test/inputs/json/misc/8592b.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/8592b.json/default/TopLevel.cr
new file mode 100644
index 0000000..f3a2b58
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/8592b.json/default/TopLevel.cr
@@ -0,0 +1,196 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : String?
+
+  property author_flair_text : String?
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : Nil
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : String
+
+  property link_flair_text : String
+
+  property locked : Bool
+
+  property media : Nil
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property post_hint : String?
+
+  property preview : Preview?
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Nil
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : String?
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : String
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32?
+
+  property thumbnail_width : Int32?
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : MediaEmbed
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/88130.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/88130.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/88130.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/8a62c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/8a62c.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/8a62c.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/908db.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/908db.json/default/TopLevel.cr
new file mode 100644
index 0000000..168ec54
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/908db.json/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property states : Array(StateElement)
+end
+
+class StateElement
+  include JSON::Serializable
+
+  property state : StateState
+end
+
+class StateState
+  include JSON::Serializable
+
+  property state_id : String
+
+  property state_name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/9617f.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/9617f.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/9617f.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/96f7c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/96f7c.json/default/TopLevel.cr
new file mode 100644
index 0000000..037d956
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/96f7c.json/default/TopLevel.cr
@@ -0,0 +1,17 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property git : Array(String)
+
+  property github_services_sha : String
+
+  property hooks : Array(String)
+
+  property importer : Array(String)
+
+  property pages : Array(String)
+
+  property verifiable_password_authentication : Bool
+end
diff --git a/head/crystal/test/inputs/json/misc/9847b.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/9847b.json/default/TopLevel.cr
new file mode 100644
index 0000000..cf510c3
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/9847b.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/9929c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/9929c.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/9929c.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/996bd.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/996bd.json/default/TopLevel.cr
new file mode 100644
index 0000000..a9162f1
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/996bd.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : String?
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/9a503.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/9a503.json/default/TopLevel.cr
new file mode 100644
index 0000000..8c033c5
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/9a503.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : Nil
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/9ac3b.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/9ac3b.json/default/TopLevel.cr
new file mode 100644
index 0000000..3f3576a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/9ac3b.json/default/TopLevel.cr
@@ -0,0 +1,51 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property created_at : String
+
+  property entity : String
+
+  property first_name : String
+
+  property id : String
+
+  property last_name : String
+
+  property name : String
+
+  property position : String?
+
+  property status : String
+
+  property title : String?
+
+  property updated_at : String
+
+  property uri : String
+end
diff --git a/head/crystal/test/inputs/json/misc/9eed5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/9eed5.json/default/TopLevel.cr
new file mode 100644
index 0000000..8c033c5
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/9eed5.json/default/TopLevel.cr
@@ -0,0 +1,49 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(JSON::Any?)
+
+  property superseded_by : Nil
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/a0496.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/a0496.json/default/TopLevel.cr
new file mode 100644
index 0000000..dc23647
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/a0496.json/default/TopLevel.cr
@@ -0,0 +1,47 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property code : String
+
+  property column_names : Array(String)
+
+  property data : Array(Array(Datum?))
+
+  property description : String
+
+  property display_url : String
+
+  property errors : Errors
+
+  property frequency : String
+
+  property from_date : String
+
+  property id : Int32
+
+  property name : String
+
+  property premium : Bool
+
+  property source_code : String
+
+  property source_name : String
+
+  property to_date : String
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+
+  property updated_at : String
+
+  property urlize_name : String
+end
+
+class Errors
+  include JSON::Serializable
+
+end
+
+alias Datum = Float64 | String
diff --git a/head/crystal/test/inputs/json/misc/a1eca.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/a1eca.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/a1eca.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/a3d8c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/a3d8c.json/default/TopLevel.cr
new file mode 100644
index 0000000..3b8f41c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/a3d8c.json/default/TopLevel.cr
@@ -0,0 +1,240 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum?))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property license : License
+
+  @[JSON::Field(key: "licenseId")]
+  property license_id : String
+
+  property locale : String
+
+  property metadata : Metadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowClass")]
+  property row_class : String
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Query
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property average : String?
+
+  property largest : String
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String
+
+  property sum : String?
+
+  property top : Array(Top)
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Query
+  include JSON::Serializable
+
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class License
+  include JSON::Serializable
+
+  property name : String
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  @[JSON::Field(key: "rdfClass")]
+  property rdf_class : String
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+
+  @[JSON::Field(key: "rowIdentifier")]
+  property row_identifier : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/a45b0.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/a45b0.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/a45b0.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/a71df.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/a71df.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/a71df.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/a9691.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/a9691.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/a9691.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/ab0d1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ab0d1.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ab0d1.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/abb4b.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/abb4b.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/abb4b.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/ac944.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ac944.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ac944.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/ad8be.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ad8be.json/default/TopLevel.cr
new file mode 100644
index 0000000..6d7a453
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ad8be.json/default/TopLevel.cr
@@ -0,0 +1,57 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property identifiers : Array(Identifier)
+
+  property keywords : Array(String)
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property other_names : Array(OtherName)
+
+  property superseded_by : String?
+
+  property text : Array(Text)
+end
+
+class Identifier
+  include JSON::Serializable
+
+  property identifier : String
+
+  property scheme : String
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property note : String
+
+  property url : String
+end
+
+class OtherName
+  include JSON::Serializable
+
+  property name : String
+
+  property note : String?
+end
+
+class Text
+  include JSON::Serializable
+
+  property media_type : String
+
+  property title : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/ae7f0.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ae7f0.json/default/TopLevel.cr
new file mode 100644
index 0000000..0631809
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ae7f0.json/default/TopLevel.cr
@@ -0,0 +1,158 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : Nil
+
+  property author_flair_text : Nil
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : Nil
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : String?
+
+  property link_flair_text : String?
+
+  property locked : Bool
+
+  property media : Nil
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Nil
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : Nil
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : Nil
+
+  property thumbnail : String
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+end
diff --git a/head/crystal/test/inputs/json/misc/ae9ca.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ae9ca.json/default/TopLevel.cr
new file mode 100644
index 0000000..1a891b3
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ae9ca.json/default/TopLevel.cr
@@ -0,0 +1,64 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property features : Array(Feature)
+
+  property name : String
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Feature
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property feature_type : String
+
+  property geometry : Geometry
+
+  property properties : Properties
+end
+
+class Geometry
+  include JSON::Serializable
+
+  property coordinates : Array(Float64)
+
+  @[JSON::Field(key: "type")]
+  property geometry_type : String
+end
+
+class Properties
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Area")]
+  property area : String
+
+  @[JSON::Field(key: "Central Asset ID")]
+  property central_asset_id : String
+
+  @[JSON::Field(key: "Feature Location")]
+  property feature_location : String
+
+  property lat : String
+
+  property long : String
+
+  @[JSON::Field(key: "Maintaining Authority")]
+  property maintaining_authority : String
+
+  @[JSON::Field(key: "Number")]
+  property number : String
+
+  @[JSON::Field(key: "Class")]
+  property properties_class : String
+
+  @[JSON::Field(key: "Site Name")]
+  property site_name : String
+
+  @[JSON::Field(key: "Ward")]
+  property ward : String
+end
diff --git a/head/crystal/test/inputs/json/misc/af2d1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/af2d1.json/default/TopLevel.cr
new file mode 100644
index 0000000..c2972b4
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/af2d1.json/default/TopLevel.cr
@@ -0,0 +1,136 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property crs : Crs
+
+  property features : Array(Feature)
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+
+  @[JSON::Field(key: "totalFeatures")]
+  property total_features : Int32
+end
+
+class Crs
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property crs_type : String
+
+  property properties : CrsProperties
+end
+
+class CrsProperties
+  include JSON::Serializable
+
+  property name : String
+end
+
+class Feature
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property feature_type : String
+
+  property geometry : Geometry
+
+  property geometry_name : String
+
+  property id : String
+
+  property properties : FeatureProperties
+end
+
+class Geometry
+  include JSON::Serializable
+
+  property coordinates : Array(Array(Array(Array(Float64))))
+
+  @[JSON::Field(key: "type")]
+  property geometry_type : String
+end
+
+class FeatureProperties
+  include JSON::Serializable
+
+  property add_improv : String?
+
+  @[JSON::Field(key: "area_")]
+  property area : Float64
+
+  property asset_numb : String
+
+  property comments : String?
+
+  property condition : Int32
+
+  property constructi : String?
+
+  property createdate : Nil
+
+  property createuser : Nil
+
+  property disposal_d : Nil
+
+  property documents : String
+
+  property drawing_nu : String?
+
+  property file_numbe : String?
+
+  property folder_num : String?
+
+  property funding_ba : String?
+
+  property historic_c : Int32
+
+  property inspection : String
+
+  property inspectors : Nil
+
+  property last_updat : Nil
+
+  property level_accu : String?
+
+  property material : String
+
+  property mi_prinx : Int32
+
+  property mi_symbolo : String
+
+  property number_lan : Int32
+
+  property owner : String?
+
+  property positional : String?
+
+  property project_nu : String?
+
+  @[JSON::Field(key: "type")]
+  property properties_type : String?
+
+  property rec_id : Int32
+
+  property record_cre : String?
+
+  property shape_area : Float64
+
+  property shape_leng : Float64
+
+  property status : String
+
+  property survey_num : Nil
+
+  property toe_rl : Float64
+
+  property top_rl : Float64
+
+  property update_dat : String
+
+  property updatedate : Nil
+
+  property updateuser : Nil
+end
diff --git a/head/crystal/test/inputs/json/misc/b4865.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/b4865.json/default/TopLevel.cr
new file mode 100644
index 0000000..86d80cd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/b4865.json/default/TopLevel.cr
@@ -0,0 +1,42 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: ":@computed_region_cbhk_fwbd")]
+  property computed_region_cbhk_fwbd : String?
+
+  @[JSON::Field(key: ":@computed_region_nnqa_25f4")]
+  property computed_region_nnqa_25_f4 : String?
+
+  property fall : String
+
+  property geolocation : Geolocation?
+
+  property id : String
+
+  property mass : String?
+
+  property name : String
+
+  property nametype : String
+
+  property recclass : String
+
+  property reclat : String?
+
+  property reclong : String?
+
+  property year : String?
+end
+
+class Geolocation
+  include JSON::Serializable
+
+  property coordinates : Array(Float64)
+
+  @[JSON::Field(key: "type")]
+  property geolocation_type : String
+end
diff --git a/head/crystal/test/inputs/json/misc/b6f2c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/b6f2c.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/b6f2c.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/b6fe5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/b6fe5.json/default/TopLevel.cr
new file mode 100644
index 0000000..109e0b3
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/b6fe5.json/default/TopLevel.cr
@@ -0,0 +1,14 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property group : String
+
+  property movie : String
+
+  @[JSON::Field(key: "movie-image")]
+  property movie_image : String
+
+  property theater : String
+end
diff --git a/head/crystal/test/inputs/json/misc/b9f64.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/b9f64.json/default/TopLevel.cr
new file mode 100644
index 0000000..1c7ed5f
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/b9f64.json/default/TopLevel.cr
@@ -0,0 +1,8 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "user-agent")]
+  property user_agent : String
+end
diff --git a/head/crystal/test/inputs/json/misc/bb1ec.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/bb1ec.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/bb1ec.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/be234.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/be234.json/default/TopLevel.cr
new file mode 100644
index 0000000..e034510
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/be234.json/default/TopLevel.cr
@@ -0,0 +1,257 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : Nil
+
+  property author_flair_text : String?
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : String?
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : Nil
+
+  property link_flair_text : Nil
+
+  property locked : Bool
+
+  property media : Media?
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property post_hint : String
+
+  property preview : Preview
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Media?
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : Nil
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : Nil
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32
+
+  property thumbnail_width : Int32
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class Media
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property media_type : String
+
+  property oembed : Oembed
+end
+
+class Oembed
+  include JSON::Serializable
+
+  property description : String
+
+  property height : Int32
+
+  property html : String
+
+  @[JSON::Field(key: "type")]
+  property oembed_type : String
+
+  property provider_name : String
+
+  property provider_url : String
+
+  property thumbnail_height : Int32
+
+  property thumbnail_url : String
+
+  property thumbnail_width : Int32
+
+  property title : String
+
+  property version : String
+
+  property width : Int32
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+  property content : String?
+
+  property height : Int32?
+
+  property scrolling : Bool?
+
+  property width : Int32?
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : Variants
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Variants
+  include JSON::Serializable
+
+  property gif : Gif?
+
+  property mp4 : Gif?
+end
+
+class Gif
+  include JSON::Serializable
+
+  property resolutions : Array(Source)
+
+  property source : Source
+end
diff --git a/head/crystal/test/inputs/json/misc/c0356.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/c0356.json/default/TopLevel.cr
new file mode 100644
index 0000000..99bce73
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/c0356.json/default/TopLevel.cr
@@ -0,0 +1,27 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Hash(String, Datum)
+
+  property description : Description
+end
+
+class Datum
+  include JSON::Serializable
+
+  property anomaly : String
+
+  property value : String
+end
+
+class Description
+  include JSON::Serializable
+
+  property base_period : String
+
+  property missing : Int32
+
+  property title : String
+end
diff --git a/head/crystal/test/inputs/json/misc/c0a3a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/c0a3a.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/c0a3a.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/c3303.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/c3303.json/default/TopLevel.cr
new file mode 100644
index 0000000..a2df6d1
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/c3303.json/default/TopLevel.cr
@@ -0,0 +1,193 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+
+  @[JSON::Field(key: "480w_still")]
+  property the_480_w_still : Downsized?
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/c6cfd.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/c6cfd.json/default/TopLevel.cr
new file mode 100644
index 0000000..2f6ffdc
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/c6cfd.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property countries : Array(Country)
+end
+
+class Country
+  include JSON::Serializable
+
+  property code : String
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/c8c7e.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/c8c7e.json/default/TopLevel.cr
new file mode 100644
index 0000000..4b9cdae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/c8c7e.json/default/TopLevel.cr
@@ -0,0 +1,39 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  property country : Country
+
+  property date : String
+
+  property decimal : String
+
+  property indicator : Country
+
+  property value : String
+end
+
+class Country
+  include JSON::Serializable
+
+  property id : String
+
+  property value : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  property page : Int32
+
+  property pages : Int32
+
+  property per_page : String
+
+  property total : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/misc/cb0cc.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cb0cc.json/default/TopLevel.cr
new file mode 100644
index 0000000..e6017ac
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cb0cc.json/default/TopLevel.cr
@@ -0,0 +1,34 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property prizes : Array(Prize)
+end
+
+class Prize
+  include JSON::Serializable
+
+  property category : String
+
+  property laureates : Array(Laureate)
+
+  @[JSON::Field(key: "overallMotivation")]
+  property overall_motivation : String?
+
+  property year : String
+end
+
+class Laureate
+  include JSON::Serializable
+
+  property firstname : String
+
+  property id : String
+
+  property motivation : String?
+
+  property share : String
+
+  property surname : String
+end
diff --git a/head/crystal/test/inputs/json/misc/cb81e.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cb81e.json/default/TopLevel.cr
new file mode 100644
index 0000000..ebb5fbf
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cb81e.json/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Hash(String, String)
+
+  property description : Description
+end
+
+class Description
+  include JSON::Serializable
+
+  property base_period : String
+
+  property missing : String
+
+  property title : String
+
+  property units : String
+end
diff --git a/head/crystal/test/inputs/json/misc/ccd18.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ccd18.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ccd18.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/cd238.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cd238.json/default/TopLevel.cr
new file mode 100644
index 0000000..54b90dd
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cd238.json/default/TopLevel.cr
@@ -0,0 +1,76 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property city : String
+
+  property delay : String
+
+  @[JSON::Field(key: "IATA")]
+  property iata : String
+
+  @[JSON::Field(key: "ICAO")]
+  property icao : String
+
+  property name : String
+
+  property state : String
+
+  property status : Status
+
+  property weather : Weather
+end
+
+class Status
+  include JSON::Serializable
+
+  @[JSON::Field(key: "avgDelay")]
+  property avg_delay : String
+
+  @[JSON::Field(key: "closureBegin")]
+  property closure_begin : String
+
+  @[JSON::Field(key: "closureEnd")]
+  property closure_end : String
+
+  @[JSON::Field(key: "endTime")]
+  property end_time : String
+
+  @[JSON::Field(key: "maxDelay")]
+  property max_delay : String
+
+  @[JSON::Field(key: "minDelay")]
+  property min_delay : String
+
+  property reason : String
+
+  @[JSON::Field(key: "type")]
+  property status_type : String
+
+  property trend : String
+end
+
+class Weather
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property temp : String
+
+  property visibility : Float64
+
+  property weather : String
+
+  property wind : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property credit : String
+
+  property updated : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/misc/cd463.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cd463.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cd463.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/cda6c.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cda6c.json/default/TopLevel.cr
new file mode 100644
index 0000000..4b9cdae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cda6c.json/default/TopLevel.cr
@@ -0,0 +1,39 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  property country : Country
+
+  property date : String
+
+  property decimal : String
+
+  property indicator : Country
+
+  property value : String
+end
+
+class Country
+  include JSON::Serializable
+
+  property id : String
+
+  property value : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  property page : Int32
+
+  property pages : Int32
+
+  property per_page : String
+
+  property total : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/misc/cf0d8.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cf0d8.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cf0d8.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/cfbce.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/cfbce.json/default/TopLevel.cr
new file mode 100644
index 0000000..f6aac04
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/cfbce.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property base : String
+
+  property date : String
+
+  property rates : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/misc/d0908.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/d0908.json/default/TopLevel.cr
new file mode 100644
index 0000000..6e324be
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/d0908.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property total_population : Array(TotalPopulation)
+end
+
+class TotalPopulation
+  include JSON::Serializable
+
+  property date : String
+
+  property population : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/d23d5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/d23d5.json/default/TopLevel.cr
new file mode 100644
index 0000000..fa049c2
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/d23d5.json/default/TopLevel.cr
@@ -0,0 +1,41 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property count : Int32
+
+  property facets : Facets
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Bool
+
+  property results : Array(Result)
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : String
+end
+
+class Facets
+  include JSON::Serializable
+
+end
+
+class Result
+  include JSON::Serializable
+
+  property acronym : String?
+
+  property created_at : String
+
+  property id : String
+
+  property name : String
+
+  property updated_at : String
+
+  property uri : String
+end
diff --git a/head/crystal/test/inputs/json/misc/dbfb3.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/dbfb3.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/dbfb3.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/dc44f.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/dc44f.json/default/TopLevel.cr
new file mode 100644
index 0000000..98c7de0
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/dc44f.json/default/TopLevel.cr
@@ -0,0 +1,112 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property booster : Array(String)
+
+  property border : String
+
+  property cards : Array(Card)
+
+  property code : String
+
+  @[JSON::Field(key: "gathererCode")]
+  property gatherer_code : String
+
+  @[JSON::Field(key: "magicCardsInfoCode")]
+  property magic_cards_info_code : String
+
+  property mkm_id : Int32
+
+  property mkm_name : String
+
+  property name : String
+
+  @[JSON::Field(key: "releaseDate")]
+  property release_date : String
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Card
+  include JSON::Serializable
+
+  property artist : String
+
+  @[JSON::Field(key: "type")]
+  property card_type : String
+
+  property cmc : Int32
+
+  @[JSON::Field(key: "colorIdentity")]
+  property color_identity : Array(String)?
+
+  property colors : Array(String)?
+
+  property flavor : String?
+
+  property id : String
+
+  @[JSON::Field(key: "imageName")]
+  property image_name : String
+
+  property layout : String
+
+  property legalities : Array(LegalityElement)
+
+  @[JSON::Field(key: "manaCost")]
+  property mana_cost : String?
+
+  @[JSON::Field(key: "mciNumber")]
+  property mci_number : String?
+
+  property multiverseid : Int32
+
+  property name : String
+
+  @[JSON::Field(key: "originalText")]
+  property original_text : String?
+
+  @[JSON::Field(key: "originalType")]
+  property original_type : String
+
+  property power : String?
+
+  property printings : Array(String)
+
+  property rarity : String
+
+  property reserved : Bool?
+
+  property rulings : Array(Ruling)?
+
+  property subtypes : Array(String)?
+
+  property supertypes : Array(String)?
+
+  property text : String?
+
+  property toughness : String?
+
+  property types : Array(String)
+
+  property variations : Array(Int32)?
+end
+
+class LegalityElement
+  include JSON::Serializable
+
+  property format : String
+
+  property legality : String
+end
+
+class Ruling
+  include JSON::Serializable
+
+  property date : String
+
+  property text : String
+end
diff --git a/head/crystal/test/inputs/json/misc/dd1ce.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/dd1ce.json/default/TopLevel.cr
new file mode 100644
index 0000000..98c7de0
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/dd1ce.json/default/TopLevel.cr
@@ -0,0 +1,112 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property booster : Array(String)
+
+  property border : String
+
+  property cards : Array(Card)
+
+  property code : String
+
+  @[JSON::Field(key: "gathererCode")]
+  property gatherer_code : String
+
+  @[JSON::Field(key: "magicCardsInfoCode")]
+  property magic_cards_info_code : String
+
+  property mkm_id : Int32
+
+  property mkm_name : String
+
+  property name : String
+
+  @[JSON::Field(key: "releaseDate")]
+  property release_date : String
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Card
+  include JSON::Serializable
+
+  property artist : String
+
+  @[JSON::Field(key: "type")]
+  property card_type : String
+
+  property cmc : Int32
+
+  @[JSON::Field(key: "colorIdentity")]
+  property color_identity : Array(String)?
+
+  property colors : Array(String)?
+
+  property flavor : String?
+
+  property id : String
+
+  @[JSON::Field(key: "imageName")]
+  property image_name : String
+
+  property layout : String
+
+  property legalities : Array(LegalityElement)
+
+  @[JSON::Field(key: "manaCost")]
+  property mana_cost : String?
+
+  @[JSON::Field(key: "mciNumber")]
+  property mci_number : String?
+
+  property multiverseid : Int32
+
+  property name : String
+
+  @[JSON::Field(key: "originalText")]
+  property original_text : String?
+
+  @[JSON::Field(key: "originalType")]
+  property original_type : String
+
+  property power : String?
+
+  property printings : Array(String)
+
+  property rarity : String
+
+  property reserved : Bool?
+
+  property rulings : Array(Ruling)?
+
+  property subtypes : Array(String)?
+
+  property supertypes : Array(String)?
+
+  property text : String?
+
+  property toughness : String?
+
+  property types : Array(String)
+
+  property variations : Array(Int32)?
+end
+
+class LegalityElement
+  include JSON::Serializable
+
+  property format : String
+
+  property legality : String
+end
+
+class Ruling
+  include JSON::Serializable
+
+  property date : String
+
+  property text : String
+end
diff --git a/head/crystal/test/inputs/json/misc/dec3a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/dec3a.json/default/TopLevel.cr
new file mode 100644
index 0000000..da3dfd6
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/dec3a.json/default/TopLevel.cr
@@ -0,0 +1,120 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property metadata : Metadata
+
+  property results : Array(Result)
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "executionTime")]
+  property execution_time : Float64
+
+  @[JSON::Field(key: "responseInfo")]
+  property response_info : ResponseInfo
+
+  property resultset : Resultset
+end
+
+class ResponseInfo
+  include JSON::Serializable
+
+  @[JSON::Field(key: "developerMessage")]
+  property developer_message : String
+
+  property status : Int32
+end
+
+class Resultset
+  include JSON::Serializable
+
+  property count : Int32
+
+  property page : Int32
+
+  property pagesize : Int32
+end
+
+class Result
+  include JSON::Serializable
+
+  property about_office : String
+
+  property application_process : String
+
+  property body : String
+
+  property changed : String
+
+  property created : String
+
+  property deadline : Nil
+
+  property hiring_office : Nil
+
+  property hiring_org : HiringOrg
+
+  property job_id : Nil
+
+  property language : String
+
+  property location : Location
+
+  property num_positions : String
+
+  property position : String
+
+  property practice_area : String
+
+  property qualifications : String
+
+  property relocation_expenses : Nil
+
+  property salary : String
+
+  property title : String
+
+  property travel : String
+
+  property url : String
+
+  property uuid : String
+
+  property vuuid : String
+end
+
+class HiringOrg
+  include JSON::Serializable
+
+  property name : String
+
+  property uuid : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property administrative_area : String
+
+  property country : String
+
+  property fax_number : String
+
+  property locality : String
+
+  property mobile_number : String
+
+  property phone_number : String
+
+  property phone_number_extension : String
+
+  property postal_code : String
+
+  property sub_premise : Nil
+
+  property thoroughfare : String
+end
diff --git a/head/crystal/test/inputs/json/misc/df957.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/df957.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/df957.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/e0ac7.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e0ac7.json/default/TopLevel.cr
new file mode 100644
index 0000000..4971ae8
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e0ac7.json/default/TopLevel.cr
@@ -0,0 +1,194 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property hd : DownsizedSmall?
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/e2915.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e2915.json/default/TopLevel.cr
new file mode 100644
index 0000000..e8c4b6a
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e2915.json/default/TopLevel.cr
@@ -0,0 +1,180 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property query : Query
+end
+
+class Query
+  include JSON::Serializable
+
+  property count : Int32
+
+  property created : String
+
+  property lang : String
+
+  property results : Results
+end
+
+class Results
+  include JSON::Serializable
+
+  property channel : ChannelClass
+end
+
+class ChannelClass
+  include JSON::Serializable
+
+  property astronomy : Astronomy
+
+  property atmosphere : Atmosphere
+
+  property description : String
+
+  property image : Image
+
+  property item : Item
+
+  property language : String
+
+  @[JSON::Field(key: "lastBuildDate")]
+  property last_build_date : String
+
+  property link : String
+
+  property location : Location
+
+  property title : String
+
+  property ttl : String
+
+  property units : Units
+
+  property wind : Wind
+end
+
+class Astronomy
+  include JSON::Serializable
+
+  property sunrise : String
+
+  property sunset : String
+end
+
+class Atmosphere
+  include JSON::Serializable
+
+  property humidity : String
+
+  property pressure : String
+
+  property rising : String
+
+  property visibility : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : String
+
+  property link : String
+
+  property title : String
+
+  property url : String
+
+  property width : String
+end
+
+class Item
+  include JSON::Serializable
+
+  property condition : Condition
+
+  property description : String
+
+  property forecast : Array(Forecast)
+
+  property guid : Guid
+
+  property lat : String
+
+  property link : String
+
+  property long : String
+
+  @[JSON::Field(key: "pubDate")]
+  property pub_date : String
+
+  property title : String
+end
+
+class Condition
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property temp : String
+
+  property text : String
+end
+
+class Forecast
+  include JSON::Serializable
+
+  property code : String
+
+  property date : String
+
+  property day : String
+
+  property high : String
+
+  property low : String
+
+  property text : String
+end
+
+class Guid
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPermaLink")]
+  property is_perma_link : String
+end
+
+class Location
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property region : String
+end
+
+class Units
+  include JSON::Serializable
+
+  property distance : String
+
+  property pressure : String
+
+  property speed : String
+
+  property temperature : String
+end
+
+class Wind
+  include JSON::Serializable
+
+  property chill : String
+
+  property direction : String
+
+  property speed : String
+end
diff --git a/head/crystal/test/inputs/json/misc/e2a58.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e2a58.json/default/TopLevel.cr
new file mode 100644
index 0000000..512b351
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e2a58.json/default/TopLevel.cr
@@ -0,0 +1,12 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property date : String
+
+  @[JSON::Field(key: "stop-and-search")]
+  property stop_and_search : Array(String)
+end
diff --git a/head/crystal/test/inputs/json/misc/e324e.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e324e.json/default/TopLevel.cr
new file mode 100644
index 0000000..6c40d40
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e324e.json/default/TopLevel.cr
@@ -0,0 +1,130 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "basePath")]
+  property base_path : String
+
+  property definitions : Definitions
+
+  property host : String
+
+  property info : Info
+
+  property paths : Paths
+
+  property produces : Array(String)
+
+  property schemes : Array(String)
+
+  property swagger : String
+end
+
+class Definitions
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Rate")]
+  property rate : Rate
+end
+
+class Rate
+  include JSON::Serializable
+
+  property properties : Hash(String, Property)
+end
+
+class Property
+  include JSON::Serializable
+
+  property description : String
+
+  @[JSON::Field(key: "type")]
+  property property_type : String
+end
+
+class Info
+  include JSON::Serializable
+
+  property description : String
+
+  property title : String
+
+  property version : String
+end
+
+class Paths
+  include JSON::Serializable
+
+  @[JSON::Field(key: "/tariff_rates/search")]
+  property tariff_rates_search : TariffRatesSearch
+end
+
+class TariffRatesSearch
+  include JSON::Serializable
+
+  property get : Get
+end
+
+class Get
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : Responses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class Parameter
+  include JSON::Serializable
+
+  property description : String
+
+  property format : String
+
+  property name : String
+
+  @[JSON::Field(key: "in")]
+  property parameter_in : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : String
+
+  property required : Bool
+end
+
+class Responses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : The200
+end
+
+class The200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : Schema
+end
+
+class Schema
+  include JSON::Serializable
+
+  property items : Items
+
+  @[JSON::Field(key: "type")]
+  property schema_type : String
+end
+
+class Items
+  include JSON::Serializable
+
+  @[JSON::Field(key: "$ref")]
+  property ref : String
+end
diff --git a/head/crystal/test/inputs/json/misc/e53b5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e53b5.json/default/TopLevel.cr
new file mode 100644
index 0000000..4b9cdae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e53b5.json/default/TopLevel.cr
@@ -0,0 +1,39 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  property country : Country
+
+  property date : String
+
+  property decimal : String
+
+  property indicator : Country
+
+  property value : String
+end
+
+class Country
+  include JSON::Serializable
+
+  property id : String
+
+  property value : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  property page : Int32
+
+  property pages : Int32
+
+  property per_page : String
+
+  property total : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/misc/e64a0.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e64a0.json/default/TopLevel.cr
new file mode 100644
index 0000000..ac985ae
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e64a0.json/default/TopLevel.cr
@@ -0,0 +1,34 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property args : Args
+
+  property headers : Headers
+
+  property origin : String
+
+  property url : String
+end
+
+class Args
+  include JSON::Serializable
+
+end
+
+class Headers
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Accept-Encoding")]
+  property accept_encoding : String
+
+  @[JSON::Field(key: "Connection")]
+  property connection : String
+
+  @[JSON::Field(key: "Host")]
+  property host : String
+
+  @[JSON::Field(key: "User-Agent")]
+  property user_agent : String
+end
diff --git a/head/crystal/test/inputs/json/misc/e8a0b.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e8a0b.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e8a0b.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/e8b04.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/e8b04.json/default/TopLevel.cr
new file mode 100644
index 0000000..2981ea7
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/e8b04.json/default/TopLevel.cr
@@ -0,0 +1,404 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String?
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  property description : String?
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String?
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)?
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32?
+
+  property locale : String
+
+  property metadata : TopLevelMetadata
+
+  @[JSON::Field(key: "moderationStatus")]
+  property moderation_status : Bool?
+
+  @[JSON::Field(key: "modifyingViewUid")]
+  property modifying_view_uid : String?
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32?
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property ratings : Ratings?
+
+  @[JSON::Field(key: "resourceName")]
+  property resource_name : String?
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowClass")]
+  property row_class : String?
+
+  @[JSON::Field(key: "rowIdentifierColumnId")]
+  property row_identifier_column_id : Int32?
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32?
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String?
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : TableAuthor
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  property tags : Array(String)?
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class TopLevelMetadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)?
+
+  property custom_fields : CustomFields?
+
+  @[JSON::Field(key: "jsonQuery")]
+  property json_query : JsonQuery?
+
+  @[JSON::Field(key: "rdfClass")]
+  property rdf_class : String?
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String?
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : MetadataRenderTypeConfig?
+
+  @[JSON::Field(key: "richRendererConfigs")]
+  property rich_renderer_configs : RichRendererConfigs?
+
+  @[JSON::Field(key: "rowIdentifier")]
+  property row_identifier : String?
+
+  @[JSON::Field(key: "rowLabel")]
+  property row_label : String?
+
+  property v1_archived_properties : V1ArchivedProperties?
+end
+
+class CustomFields
+  include JSON::Serializable
+
+  @[JSON::Field(key: "TEST")]
+  property test : Test
+end
+
+class Test
+  include JSON::Serializable
+
+  @[JSON::Field(key: "CFPB1")]
+  property cfpb1 : String
+end
+
+class JsonQuery
+  include JSON::Serializable
+
+  property group : Array(Group)?
+
+  @[JSON::Field(key: "select")]
+  property json_query_select : Array(Select)?
+
+  property order : Array(Order)?
+
+  property where : Where?
+end
+
+class Group
+  include JSON::Serializable
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class Select
+  include JSON::Serializable
+
+  property aggregate : String?
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class Order
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class Where
+  include JSON::Serializable
+
+  property children : Array(Child)?
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String?
+
+  property metadata : ChildMetadata?
+
+  property operator : String
+
+  property value : String?
+end
+
+class Child
+  include JSON::Serializable
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+
+  property metadata : ChildMetadata?
+
+  property operator : String
+
+  property value : String?
+end
+
+class ChildMetadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "customValues")]
+  property custom_values : Array(String)?
+
+  property freeform : Bool?
+
+  @[JSON::Field(key: "includeAuto")]
+  property include_auto : Int32?
+
+  property operator : String?
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : TableColumnId?
+
+  @[JSON::Field(key: "unifiedVersion")]
+  property unified_version : Int32?
+end
+
+class TableColumnId
+  include JSON::Serializable
+
+  @[JSON::Field(key: "2819740")]
+  property the_2819740 : Int32
+end
+
+class MetadataRenderTypeConfig
+  include JSON::Serializable
+
+  property visible : PurpleVisible
+end
+
+class PurpleVisible
+  include JSON::Serializable
+
+  property fatrow : Bool?
+
+  property table : Bool?
+end
+
+class RichRendererConfigs
+  include JSON::Serializable
+
+  @[JSON::Field(key: "fatRow")]
+  property fat_row : FatRow
+end
+
+class FatRow
+  include JSON::Serializable
+
+  property columns : Array(Column)
+end
+
+class Column
+  include JSON::Serializable
+
+  property rows : Array(Row)
+
+  property styles : Styles
+end
+
+class Row
+  include JSON::Serializable
+
+  property fields : Array(Field)
+end
+
+class Field
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property field_type : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32
+end
+
+class Styles
+  include JSON::Serializable
+
+  property width : String
+end
+
+class V1ArchivedProperties
+  include JSON::Serializable
+
+  @[JSON::Field(key: "accessPoints")]
+  property access_points : AccessPoints
+
+  property blist_id : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : V1ArchivedPropertiesRenderTypeConfig
+end
+
+class AccessPoints
+  include JSON::Serializable
+
+  property new_view : String
+end
+
+class V1ArchivedPropertiesRenderTypeConfig
+  include JSON::Serializable
+
+  property visible : FluffyVisible
+end
+
+class FluffyVisible
+  include JSON::Serializable
+
+  property href : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property flags : Array(String)?
+
+  property id : String
+
+  @[JSON::Field(key: "lastNotificationSeenAt")]
+  property last_notification_seen_at : Int32?
+
+  @[JSON::Field(key: "profileImageUrlLarge")]
+  property profile_image_url_large : String?
+
+  @[JSON::Field(key: "profileImageUrlMedium")]
+  property profile_image_url_medium : String?
+
+  @[JSON::Field(key: "profileImageUrlSmall")]
+  property profile_image_url_small : String?
+
+  property rights : Array(String)?
+
+  @[JSON::Field(key: "roleName")]
+  property role_name : String?
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+class Ratings
+  include JSON::Serializable
+
+  property rating : Int32
+end
+
+class TableAuthor
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  property rights : Array(String)?
+
+  @[JSON::Field(key: "roleName")]
+  property role_name : String?
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/ed095.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/ed095.json/default/TopLevel.cr
new file mode 100644
index 0000000..2a8e123
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/ed095.json/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Hash(String, String)
diff --git a/head/crystal/test/inputs/json/misc/f22f5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f22f5.json/default/TopLevel.cr
new file mode 100644
index 0000000..0631809
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f22f5.json/default/TopLevel.cr
@@ -0,0 +1,158 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : Nil
+
+  property author_flair_text : Nil
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Float64
+
+  property created_utc : Float64
+
+  property distinguished : Nil
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : String?
+
+  property link_flair_text : String?
+
+  property locked : Bool
+
+  property media : Nil
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property permalink : String
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Nil
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : Nil
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : Nil
+
+  property thumbnail : String
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+end
diff --git a/head/crystal/test/inputs/json/misc/f3139.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f3139.json/default/TopLevel.cr
new file mode 100644
index 0000000..cf510c3
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f3139.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property id : String
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/misc/f3edf.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f3edf.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f3edf.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/f466a.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f466a.json/default/TopLevel.cr
new file mode 100644
index 0000000..943073c
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f466a.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property age : Int32
+
+  property country : String
+
+  property females : Int32
+
+  property males : Int32
+
+  property total : Int32
+
+  property year : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/f6a65.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f6a65.json/default/TopLevel.cr
new file mode 100644
index 0000000..88dfd89
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f6a65.json/default/TopLevel.cr
@@ -0,0 +1,195 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Datum)
+
+  property meta : Meta
+
+  property pagination : Pagination
+end
+
+class Datum
+  include JSON::Serializable
+
+  property bitly_gif_url : String
+
+  property bitly_url : String
+
+  property content_url : String
+
+  @[JSON::Field(key: "type")]
+  property datum_type : String
+
+  property embed_url : String
+
+  property id : String
+
+  property images : Images
+
+  property import_datetime : String
+
+  property is_indexable : Int32
+
+  property rating : String
+
+  property slug : String
+
+  property source : String
+
+  property source_post_url : String
+
+  property source_tld : String
+
+  property trending_datetime : String
+
+  property url : String
+
+  property user : User?
+
+  property username : String
+end
+
+class Images
+  include JSON::Serializable
+
+  property downsized : Downsized
+
+  property downsized_large : Downsized
+
+  property downsized_medium : Downsized
+
+  property downsized_small : DownsizedSmall
+
+  property downsized_still : Downsized
+
+  property fixed_height : FixedHeight
+
+  property fixed_height_downsampled : FixedHeight
+
+  property fixed_height_small : FixedHeight
+
+  property fixed_height_small_still : Downsized
+
+  property fixed_height_still : Downsized
+
+  property fixed_width : FixedHeight
+
+  property fixed_width_downsampled : FixedHeight
+
+  property fixed_width_small : FixedHeight
+
+  property fixed_width_small_still : Downsized
+
+  property fixed_width_still : Downsized
+
+  property looping : Looping
+
+  property original : FixedHeight
+
+  property original_mp4 : DownsizedSmall
+
+  property original_still : Downsized
+
+  property preview : DownsizedSmall
+
+  property preview_gif : Downsized
+
+  property preview_webp : Downsized
+
+  @[JSON::Field(key: "480w_still")]
+  property the_480_w_still : Downsized?
+end
+
+class Downsized
+  include JSON::Serializable
+
+  property height : String
+
+  property size : String?
+
+  property url : String
+
+  property width : String
+end
+
+class DownsizedSmall
+  include JSON::Serializable
+
+  property height : String
+
+  property mp4 : String
+
+  property mp4_size : String
+
+  property width : String
+end
+
+class FixedHeight
+  include JSON::Serializable
+
+  property frames : String?
+
+  property hash : String?
+
+  property height : String
+
+  property mp4 : String?
+
+  property mp4_size : String?
+
+  property size : String
+
+  property url : String
+
+  property webp : String
+
+  property webp_size : String
+
+  property width : String
+end
+
+class Looping
+  include JSON::Serializable
+
+  property mp4 : String
+
+  property mp4_size : String
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property banner_url : String
+
+  property display_name : String
+
+  property profile_url : String
+
+  property twitter : String
+
+  property username : String
+end
+
+class Meta
+  include JSON::Serializable
+
+  property msg : String
+
+  property response_id : String
+
+  property status : Int32
+end
+
+class Pagination
+  include JSON::Serializable
+
+  property count : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/f74d5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f74d5.json/default/TopLevel.cr
new file mode 100644
index 0000000..d63234b
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f74d5.json/default/TopLevel.cr
@@ -0,0 +1,240 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property license : License
+
+  @[JSON::Field(key: "licenseId")]
+  property license_id : String
+
+  property locale : String
+
+  property metadata : Metadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowClass")]
+  property row_class : String
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Query
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property average : String?
+
+  property largest : String
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String
+
+  property sum : String?
+
+  property top : Array(Top)
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Query
+  include JSON::Serializable
+
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class License
+  include JSON::Serializable
+
+  property name : String
+end
+
+class Metadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  @[JSON::Field(key: "rdfClass")]
+  property rdf_class : String
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+
+  @[JSON::Field(key: "rowIdentifier")]
+  property row_identifier : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/f82d9.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f82d9.json/default/TopLevel.cr
new file mode 100644
index 0000000..b2b66ba
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f82d9.json/default/TopLevel.cr
@@ -0,0 +1,154 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "basePath")]
+  property base_path : String
+
+  property definitions : Definitions
+
+  property host : String
+
+  property info : Info
+
+  property paths : Paths
+
+  property produces : Array(String)
+
+  property schemes : Array(String)
+
+  property swagger : String
+end
+
+class Definitions
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Report")]
+  property report : Report
+end
+
+class Report
+  include JSON::Serializable
+
+  property properties : Properties
+end
+
+class Properties
+  include JSON::Serializable
+
+  property click_url : ClickUrl
+
+  property country : ClickUrl
+
+  property description : ClickUrl
+
+  property expiration_date : ClickUrl
+
+  property id : ClickUrl
+
+  property industry : ClickUrl
+
+  property report_type : ClickUrl
+
+  property source_industry : ClickUrl
+
+  property title : ClickUrl
+
+  property url : ClickUrl
+end
+
+class ClickUrl
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property click_url_type : String
+
+  property description : String
+end
+
+class Info
+  include JSON::Serializable
+
+  property description : String
+
+  property title : String
+
+  property version : String
+end
+
+class Paths
+  include JSON::Serializable
+
+  @[JSON::Field(key: "/market_research_library/search")]
+  property market_research_library_search : MarketResearchLibrarySearch
+end
+
+class MarketResearchLibrarySearch
+  include JSON::Serializable
+
+  property get : Get
+end
+
+class Get
+  include JSON::Serializable
+
+  property description : String
+
+  property parameters : Array(Parameter)
+
+  property responses : Responses
+
+  property summary : String
+
+  property tags : Array(String)
+end
+
+class Parameter
+  include JSON::Serializable
+
+  property description : String
+
+  property format : String
+
+  property name : String
+
+  @[JSON::Field(key: "in")]
+  property parameter_in : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : String
+
+  property required : Bool
+end
+
+class Responses
+  include JSON::Serializable
+
+  @[JSON::Field(key: "200")]
+  property the_200 : The200
+end
+
+class The200
+  include JSON::Serializable
+
+  property description : String
+
+  property schema : Schema
+end
+
+class Schema
+  include JSON::Serializable
+
+  property items : Items
+
+  @[JSON::Field(key: "type")]
+  property schema_type : String
+end
+
+class Items
+  include JSON::Serializable
+
+  @[JSON::Field(key: "$ref")]
+  property ref : String
+end
diff --git a/head/crystal/test/inputs/json/misc/f974d.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/f974d.json/default/TopLevel.cr
new file mode 100644
index 0000000..2ae8da8
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/f974d.json/default/TopLevel.cr
@@ -0,0 +1,16 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property block_index : Int32
+
+  property hash : String
+
+  property height : Int32
+
+  property time : Int32
+
+  @[JSON::Field(key: "txIndexes")]
+  property tx_indexes : Array(Int32)
+end
diff --git a/head/crystal/test/inputs/json/misc/faff5.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/faff5.json/default/TopLevel.cr
new file mode 100644
index 0000000..8b60597
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/faff5.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property response : Response
+end
+
+class Response
+  include JSON::Serializable
+
+  property player_count : Int32
+
+  property result : Int32
+end
diff --git a/head/crystal/test/inputs/json/misc/fcca3.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/fcca3.json/default/TopLevel.cr
new file mode 100644
index 0000000..e643dbb
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/fcca3.json/default/TopLevel.cr
@@ -0,0 +1,436 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Array(Array(Datum?))
+
+  property meta : Meta
+end
+
+class Meta
+  include JSON::Serializable
+
+  property view : View
+end
+
+class View
+  include JSON::Serializable
+
+  property attribution : String
+
+  @[JSON::Field(key: "averageRating")]
+  property average_rating : Int32
+
+  property category : String
+
+  property columns : Array(Column)
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : Int32
+
+  property description : String
+
+  @[JSON::Field(key: "displayType")]
+  property display_type : String
+
+  @[JSON::Field(key: "downloadCount")]
+  property download_count : Int32
+
+  property flags : Array(String)
+
+  property grants : Array(Grant)
+
+  @[JSON::Field(key: "hideFromCatalog")]
+  property hide_from_catalog : Bool
+
+  @[JSON::Field(key: "hideFromDataJson")]
+  property hide_from_data_json : Bool
+
+  property id : String
+
+  @[JSON::Field(key: "indexUpdatedAt")]
+  property index_updated_at : Int32
+
+  property locale : String
+
+  property metadata : ViewMetadata
+
+  property name : String
+
+  @[JSON::Field(key: "newBackend")]
+  property new_backend : Bool
+
+  @[JSON::Field(key: "numberOfComments")]
+  property number_of_comments : Int32
+
+  property oid : Int32
+
+  property owner : Owner
+
+  property provenance : String
+
+  @[JSON::Field(key: "publicationAppendEnabled")]
+  property publication_append_enabled : Bool
+
+  @[JSON::Field(key: "publicationDate")]
+  property publication_date : Int32
+
+  @[JSON::Field(key: "publicationGroup")]
+  property publication_group : Int32
+
+  @[JSON::Field(key: "publicationStage")]
+  property publication_stage : String
+
+  property query : Query
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "rowsUpdatedAt")]
+  property rows_updated_at : Int32
+
+  @[JSON::Field(key: "rowsUpdatedBy")]
+  property rows_updated_by : String
+
+  @[JSON::Field(key: "tableAuthor")]
+  property table_author : Owner
+
+  @[JSON::Field(key: "tableId")]
+  property table_id : Int32
+
+  property tags : Array(String)
+
+  @[JSON::Field(key: "totalTimesRated")]
+  property total_times_rated : Int32
+
+  @[JSON::Field(key: "viewCount")]
+  property view_count : Int32
+
+  @[JSON::Field(key: "viewLastModified")]
+  property view_last_modified : Int32
+
+  @[JSON::Field(key: "viewType")]
+  property view_type : String
+end
+
+class Column
+  include JSON::Serializable
+
+  @[JSON::Field(key: "cachedContents")]
+  property cached_contents : CachedContents?
+
+  @[JSON::Field(key: "dataTypeName")]
+  property data_type_name : String
+
+  property description : String?
+
+  @[JSON::Field(key: "fieldName")]
+  property field_name : String
+
+  property flags : Array(String)?
+
+  property format : Format
+
+  property id : Int32
+
+  property name : String
+
+  property position : Int32
+
+  @[JSON::Field(key: "renderTypeName")]
+  property render_type_name : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : Int32?
+
+  property width : Int32?
+end
+
+class CachedContents
+  include JSON::Serializable
+
+  property average : String?
+
+  property largest : String
+
+  property non_null : Int32
+
+  property null : Int32
+
+  property smallest : String
+
+  property sum : String?
+
+  property top : Array(Top)
+end
+
+class Top
+  include JSON::Serializable
+
+  property count : Int32
+
+  property item : String
+end
+
+class Format
+  include JSON::Serializable
+
+  property align : String?
+
+  @[JSON::Field(key: "noCommas")]
+  property no_commas : String?
+
+  @[JSON::Field(key: "precisionStyle")]
+  property precision_style : String?
+end
+
+class Grant
+  include JSON::Serializable
+
+  property flags : Array(String)
+
+  @[JSON::Field(key: "type")]
+  property grant_type : String
+
+  property inherited : Bool
+end
+
+class ViewMetadata
+  include JSON::Serializable
+
+  property attachments : Array(Attachment)
+
+  @[JSON::Field(key: "availableDisplayTypes")]
+  property available_display_types : Array(String)
+
+  property custom_fields : CustomFields
+
+  @[JSON::Field(key: "filterCondition")]
+  property filter_condition : FilterCondition
+
+  @[JSON::Field(key: "jsonQuery")]
+  property json_query : JsonQuery
+
+  @[JSON::Field(key: "rdfSubject")]
+  property rdf_subject : String
+
+  @[JSON::Field(key: "renderTypeConfig")]
+  property render_type_config : RenderTypeConfig
+
+  @[JSON::Field(key: "rowLabel")]
+  property row_label : String
+end
+
+class Attachment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "assetId")]
+  property asset_id : String
+
+  @[JSON::Field(key: "blobId")]
+  property blob_id : String
+
+  property filename : String
+
+  property name : String
+end
+
+class CustomFields
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Common Core")]
+  property common_core : CommonCore
+
+  @[JSON::Field(key: "Dataset Information")]
+  property dataset_information : DatasetInformation
+
+  @[JSON::Field(key: "Dataset Summary")]
+  property dataset_summary : DatasetSummary
+
+  @[JSON::Field(key: "Disclaimers")]
+  property disclaimers : Disclaimers
+end
+
+class CommonCore
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Email")]
+  property contact_email : String
+
+  @[JSON::Field(key: "Contact Name")]
+  property contact_name : String
+
+  @[JSON::Field(key: "Publisher")]
+  property publisher : String
+end
+
+class DatasetInformation
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Agency")]
+  property agency : String
+end
+
+class DatasetSummary
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Contact Information")]
+  property contact_information : String
+
+  @[JSON::Field(key: "Coverage")]
+  property coverage : String
+
+  @[JSON::Field(key: "Granularity")]
+  property granularity : String
+
+  @[JSON::Field(key: "Organization")]
+  property organization : String
+
+  @[JSON::Field(key: "Posting Frequency")]
+  property posting_frequency : String
+
+  @[JSON::Field(key: "Time Period")]
+  property time_period : String
+end
+
+class Disclaimers
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Disclaimer")]
+  property disclaimer : String
+
+  @[JSON::Field(key: "Limitations")]
+  property limitations : String
+end
+
+class FilterCondition
+  include JSON::Serializable
+
+  property children : Array(Child)
+
+  @[JSON::Field(key: "type")]
+  property filter_condition_type : String
+
+  property metadata : FilterConditionMetadata
+
+  property value : String
+end
+
+class Child
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : String
+
+  property metadata : ChildMetadata
+
+  property value : String
+end
+
+class ChildMetadata
+  include JSON::Serializable
+
+  @[JSON::Field(key: "customValues")]
+  property custom_values : Array(Array(String))
+
+  property operator : String
+
+  @[JSON::Field(key: "tableColumnId")]
+  property table_column_id : TableColumnId
+end
+
+class TableColumnId
+  include JSON::Serializable
+
+  @[JSON::Field(key: "703610")]
+  property the_703610 : Int32
+end
+
+class FilterConditionMetadata
+  include JSON::Serializable
+
+  property advanced : Bool
+
+  @[JSON::Field(key: "unifiedVersion")]
+  property unified_version : Int32
+end
+
+class JsonQuery
+  include JSON::Serializable
+
+  property order : Array(Order)
+end
+
+class Order
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  @[JSON::Field(key: "columnFieldName")]
+  property column_field_name : String
+end
+
+class RenderTypeConfig
+  include JSON::Serializable
+
+  property visible : Visible
+end
+
+class Visible
+  include JSON::Serializable
+
+  property table : Bool
+end
+
+class Owner
+  include JSON::Serializable
+
+  @[JSON::Field(key: "displayName")]
+  property display_name : String
+
+  property id : String
+
+  @[JSON::Field(key: "profileImageUrlLarge")]
+  property profile_image_url_large : String
+
+  @[JSON::Field(key: "profileImageUrlMedium")]
+  property profile_image_url_medium : String
+
+  @[JSON::Field(key: "profileImageUrlSmall")]
+  property profile_image_url_small : String
+
+  property rights : Array(String)
+
+  @[JSON::Field(key: "roleName")]
+  property role_name : String
+
+  @[JSON::Field(key: "screenName")]
+  property screen_name : String
+end
+
+class Query
+  include JSON::Serializable
+
+  @[JSON::Field(key: "orderBys")]
+  property order_bys : Array(OrderBy)
+end
+
+class OrderBy
+  include JSON::Serializable
+
+  property ascending : Bool
+
+  property expression : Expression
+end
+
+class Expression
+  include JSON::Serializable
+
+  @[JSON::Field(key: "columnId")]
+  property column_id : Int32
+
+  @[JSON::Field(key: "type")]
+  property expression_type : String
+end
+
+alias Datum = Int32 | String
diff --git a/head/crystal/test/inputs/json/misc/fd329.json/default/TopLevel.cr b/head/crystal/test/inputs/json/misc/fd329.json/default/TopLevel.cr
new file mode 100644
index 0000000..c658019
--- /dev/null
+++ b/head/crystal/test/inputs/json/misc/fd329.json/default/TopLevel.cr
@@ -0,0 +1,29 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Hash(String, Datum)
+
+  property description : Description
+end
+
+class Datum
+  include JSON::Serializable
+
+  property anomaly : String
+
+  property value : String
+end
+
+class Description
+  include JSON::Serializable
+
+  property base_period : String
+
+  property missing : Int32
+
+  property title : String
+
+  property units : String
+end
diff --git a/head/crystal/test/inputs/json/priority/bug2037.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug2037.json/default/TopLevel.cr
new file mode 100644
index 0000000..e592444
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug2037.json/default/TopLevel.cr
@@ -0,0 +1,24 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property mission_specs : Hash(String, MissionSpec)
+end
+
+class MissionSpec
+  include JSON::Serializable
+
+  property objectives : Hash(String, Objective)
+end
+
+class Objective
+  include JSON::Serializable
+
+  property rewards : Hash(String, Reward)
+end
+
+class Reward
+  include JSON::Serializable
+
+end
diff --git a/head/crystal/test/inputs/json/priority/bug2521.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug2521.json/default/TopLevel.cr
new file mode 100644
index 0000000..52882f4
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug2521.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property options : Array(Option)
+end
+
+class Option
+  include JSON::Serializable
+
+  property foo : String?
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/priority/bug2590.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug2590.json/default/TopLevel.cr
new file mode 100644
index 0000000..90aedb3
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug2590.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property invoices : Array(Invoice)
+end
+
+class Invoice
+  include JSON::Serializable
+
+  @[JSON::Field(key: "createdAt")]
+  property created_at : String?
+
+  @[JSON::Field(key: "dueDate")]
+  property due_date : String?
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/priority/bug2663.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug2663.json/default/TopLevel.cr
new file mode 100644
index 0000000..a3b5dee
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug2663.json/default/TopLevel.cr
@@ -0,0 +1,12 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property birthday : String
+
+  @[JSON::Field(key: "lastSeen")]
+  property last_seen : String
+
+  property name : String
+end
diff --git a/head/crystal/test/inputs/json/priority/bug2793.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug2793.json/default/TopLevel.cr
new file mode 100644
index 0000000..054e471
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug2793.json/default/TopLevel.cr
@@ -0,0 +1,26 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Hints")]
+  property hints : Hints
+
+  @[JSON::Field(key: "Labels")]
+  property labels : Labels
+end
+
+class Hints
+  include JSON::Serializable
+
+end
+
+class Labels
+  include JSON::Serializable
+
+  @[JSON::Field(key: "AccountNumber")]
+  property account_number : String
+
+  @[JSON::Field(key: "Title")]
+  property title : String
+end
diff --git a/head/crystal/test/inputs/json/priority/bug427.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug427.json/default/TopLevel.cr
new file mode 100644
index 0000000..ba3b34e
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug427.json/default/TopLevel.cr
@@ -0,0 +1,1104 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property children : Array(TopLevelChild)
+
+  property flags : GetSignatureFlags
+
+  property groups : Array(Group)
+
+  property id : Int32
+
+  property kind : Int32
+
+  property name : String
+end
+
+class TopLevelChild
+  include JSON::Serializable
+
+  property children : Array(PurpleChild)
+
+  property comment : IndecentComment?
+
+  property flags : PurpleFlags
+
+  property groups : Array(Group)
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  @[JSON::Field(key: "originalName")]
+  property original_name : String
+
+  property sources : Array(Source)
+end
+
+class PurpleChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : MagentaType?
+
+  property children : Array(FluffyChild)?
+
+  property comment : StickyComment?
+
+  @[JSON::Field(key: "defaultValue")]
+  property default_value : String?
+
+  @[JSON::Field(key: "extendedBy")]
+  property extended_by : Array(ExtendedBy)?
+
+  @[JSON::Field(key: "extendedTypes")]
+  property extended_types : Array(ExtendedBy)?
+
+  property flags : IndecentFlags
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  @[JSON::Field(key: "implementedBy")]
+  property implemented_by : Array(ExtendedBy)?
+
+  @[JSON::Field(key: "implementedTypes")]
+  property implemented_types : Array(ExtendedBy)?
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property signatures : Array(StickySignature)?
+
+  property sources : Array(Source)
+
+  @[JSON::Field(key: "typeParameter")]
+  property type_parameter : Array(TypeParameter)?
+end
+
+class MagentaType
+  include JSON::Serializable
+
+  property declaration : StickyDeclaration?
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ElementType?
+
+  property elements : Array(ExtendedBy)?
+
+  property id : Int32?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(FluffyTypeArgument)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+
+  property types : Array(ExtendedBy)?
+
+  property value : String?
+end
+
+class StickyDeclaration
+  include JSON::Serializable
+
+  property children : Array(IndecentChild)?
+
+  property flags : GetSignatureFlags
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property signatures : Array(GetSignature)
+
+  property sources : Array(Source)
+end
+
+class IndecentChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : FriskyType
+
+  property flags : FluffyFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property sources : Array(Source)
+end
+
+class FriskyType
+  include JSON::Serializable
+
+  property declaration : IndigoDeclaration?
+
+  property name : String?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class IndigoDeclaration
+  include JSON::Serializable
+
+  property children : Array(GetSignature)?
+
+  property flags : GetSignatureFlags
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property signatures : Array(GetSignature)?
+
+  property sources : Array(Source)
+end
+
+class IndexSignatureElement
+  include JSON::Serializable
+
+  property flags : GetSignatureFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property parameters : Array(GetSignature)?
+
+  @[JSON::Field(key: "type")]
+  property signature_type : PurpleType
+end
+
+class GetSignatureType
+  include JSON::Serializable
+
+  property declaration : GetSignature?
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ElementType?
+
+  property name : String?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class PurpleType
+  include JSON::Serializable
+
+  property declaration : GetSignature?
+
+  property name : String?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class GetSignatureChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : PurpleType
+
+  property comment : FluffyComment?
+
+  property flags : FluffyFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property sources : Array(Source)
+end
+
+class GetSignature
+  include JSON::Serializable
+
+  property children : Array(GetSignatureChild)?
+
+  property comment : GetSignatureComment?
+
+  @[JSON::Field(key: "defaultValue")]
+  property default_value : String?
+
+  property flags : GetSignatureFlags
+
+  @[JSON::Field(key: "type")]
+  property get_signature_type : GetSignatureType?
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property parameters : Array(GetSignatureParameter)?
+
+  property signatures : Array(IndexSignatureElement)?
+
+  property sources : Array(Source)?
+
+  @[JSON::Field(key: "typeParameter")]
+  property type_parameter : Array(GetSignature)?
+end
+
+class GetSignatureFlags
+  include JSON::Serializable
+
+end
+
+class ElementType
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property element_type_type : String
+
+  property name : String
+end
+
+class FluffyComment
+  include JSON::Serializable
+
+  property text : String
+end
+
+class FluffyFlags
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isOptional")]
+  property is_optional : Bool?
+end
+
+class Source
+  include JSON::Serializable
+
+  property character : Int32
+
+  @[JSON::Field(key: "fileName")]
+  property file_name : String
+
+  property line : Int32
+end
+
+class GetSignatureComment
+  include JSON::Serializable
+
+  property returns : String?
+
+  @[JSON::Field(key: "shortText")]
+  property short_text : String?
+
+  property text : String?
+end
+
+class Group
+  include JSON::Serializable
+
+  property children : Array(Int32)
+
+  property kind : Int32
+
+  property title : String
+end
+
+class GetSignatureParameter
+  include JSON::Serializable
+
+  property comment : TentacledComment?
+
+  property flags : TentacledFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : FluffyType
+end
+
+class TentacledComment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "shortText")]
+  property short_text : String?
+
+  property text : String?
+end
+
+class TentacledFlags
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isOptional")]
+  property is_optional : Bool?
+
+  @[JSON::Field(key: "isRest")]
+  property is_rest : Bool?
+end
+
+class FluffyType
+  include JSON::Serializable
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ElementType?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(ElementType)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class ExtendedBy
+  include JSON::Serializable
+
+  property constraint : ExtendedBy?
+
+  @[JSON::Field(key: "type")]
+  property extended_by_type : String
+
+  property id : Int32?
+
+  property name : String
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(ExtendedBy)?
+end
+
+class FluffyTypeArgument
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property type_argument_type : String
+
+  property types : Array(ElementType)
+end
+
+class FluffyChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : IndigoType?
+
+  property children : Array(TentacledChild)?
+
+  property comment : StickyComment?
+
+  @[JSON::Field(key: "defaultValue")]
+  property default_value : String?
+
+  property flags : StickyFlags
+
+  @[JSON::Field(key: "getSignature")]
+  property get_signature : GetSignature?
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  @[JSON::Field(key: "implementationOf")]
+  property implementation_of : ExtendedBy?
+
+  @[JSON::Field(key: "inheritedFrom")]
+  property inherited_from : ExtendedBy?
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property overwrites : ExtendedBy?
+
+  @[JSON::Field(key: "setSignature")]
+  property set_signature : GetSignature?
+
+  property signatures : Array(FluffySignature)?
+
+  property sources : Array(Source)
+end
+
+class IndigoType
+  include JSON::Serializable
+
+  property constraint : ExtendedBy?
+
+  property declaration : FluffyDeclaration?
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ExtendedBy?
+
+  property elements : Array(ElementType)?
+
+  property id : Int32?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(PurpleTypeArgument)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+
+  property types : Array(TypeElement)?
+end
+
+class FluffyDeclaration
+  include JSON::Serializable
+
+  property children : Array(StickyChild)?
+
+  property flags : GetSignatureFlags
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  @[JSON::Field(key: "indexSignature")]
+  property index_signature : IndexSignature?
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property signatures : Array(TentacledSignature)?
+
+  property sources : Array(Source)
+end
+
+class StickyChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : IndecentType
+
+  property comment : FluffyComment?
+
+  property flags : FluffyFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property sources : Array(Source)
+end
+
+class IndecentType
+  include JSON::Serializable
+
+  property declaration : GetSignature?
+
+  property elements : Array(ElementType)?
+
+  property name : String?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class IndexSignature
+  include JSON::Serializable
+
+  property flags : GetSignatureFlags
+
+  property id : Int32
+
+  @[JSON::Field(key: "type")]
+  property index_signature_type : HilariousType
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property parameters : Array(GetSignature)
+end
+
+class HilariousType
+  include JSON::Serializable
+
+  property declaration : GetSignature
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class TentacledSignature
+  include JSON::Serializable
+
+  property comment : IndigoComment?
+
+  property flags : GetSignatureFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property parameters : Array(FluffyParameter)?
+
+  @[JSON::Field(key: "type")]
+  property signature_type : ExtendedBy
+end
+
+class IndigoComment
+  include JSON::Serializable
+
+  property returns : String
+
+  @[JSON::Field(key: "shortText")]
+  property short_text : String
+end
+
+class FluffyParameter
+  include JSON::Serializable
+
+  property comment : FluffyComment?
+
+  property flags : FluffyFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : ElementType
+
+  property sources : Array(Source)?
+end
+
+class PurpleTypeArgument
+  include JSON::Serializable
+
+  property operator : String
+
+  property target : ElementType
+
+  @[JSON::Field(key: "type")]
+  property type_argument_type : String
+end
+
+class TypeElement
+  include JSON::Serializable
+
+  property declaration : GetSignature?
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ElementType?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(ElementType)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class TentacledChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : TypeElement?
+
+  property comment : PurpleComment?
+
+  @[JSON::Field(key: "defaultValue")]
+  property default_value : String?
+
+  property flags : PurpleFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property signatures : Array(PurpleSignature)?
+
+  property sources : Array(Source)
+end
+
+class PurpleComment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "shortText")]
+  property short_text : String
+end
+
+class PurpleFlags
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isExported")]
+  property is_exported : Bool?
+end
+
+class PurpleSignature
+  include JSON::Serializable
+
+  property comment : PurpleComment?
+
+  property flags : GetSignatureFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property parameters : Array(GetSignature)
+
+  @[JSON::Field(key: "type")]
+  property signature_type : TentacledType
+end
+
+class TentacledType
+  include JSON::Serializable
+
+  property declaration : PurpleDeclaration?
+
+  property name : String?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class PurpleDeclaration
+  include JSON::Serializable
+
+  property children : Array(GetSignature)
+
+  property flags : GetSignatureFlags
+
+  property groups : Array(Group)
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+end
+
+class StickyComment
+  include JSON::Serializable
+
+  property returns : String?
+
+  @[JSON::Field(key: "shortText")]
+  property short_text : String?
+
+  property tags : Array(Tag)?
+
+  property text : String?
+end
+
+class Tag
+  include JSON::Serializable
+
+  property tag : String
+
+  property text : String
+end
+
+class StickyFlags
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isAbstract")]
+  property is_abstract : Bool?
+
+  @[JSON::Field(key: "isConstructorProperty")]
+  property is_constructor_property : Bool?
+
+  @[JSON::Field(key: "isExported")]
+  property is_exported : Bool?
+
+  @[JSON::Field(key: "isPrivate")]
+  property is_private : Bool?
+
+  @[JSON::Field(key: "isProtected")]
+  property is_protected : Bool?
+
+  @[JSON::Field(key: "isPublic")]
+  property is_public : Bool?
+
+  @[JSON::Field(key: "isStatic")]
+  property is_static : Bool?
+end
+
+class FluffySignature
+  include JSON::Serializable
+
+  property comment : StickyComment?
+
+  property flags : IndigoFlags
+
+  property id : Int32
+
+  @[JSON::Field(key: "implementationOf")]
+  property implementation_of : ExtendedBy?
+
+  @[JSON::Field(key: "inheritedFrom")]
+  property inherited_from : ExtendedBy?
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property overwrites : ExtendedBy?
+
+  property parameters : Array(PurpleParameter)?
+
+  @[JSON::Field(key: "type")]
+  property signature_type : ExtendedBy
+
+  @[JSON::Field(key: "typeParameter")]
+  property type_parameter : Array(GetSignature)?
+end
+
+class IndigoFlags
+  include JSON::Serializable
+
+  @[JSON::Field(key: "isPrivate")]
+  property is_private : Bool?
+
+  @[JSON::Field(key: "isProtected")]
+  property is_protected : Bool?
+end
+
+class PurpleParameter
+  include JSON::Serializable
+
+  property comment : TentacledComment?
+
+  property flags : GetSignatureFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : StickyType
+end
+
+class StickyType
+  include JSON::Serializable
+
+  property constraint : ExtendedBy?
+
+  property declaration : GetSignature?
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ElementType?
+
+  property elements : Array(ExtendedBy)?
+
+  property id : Int32?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(ElementType)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class IndecentFlags
+  include JSON::Serializable
+
+  @[JSON::Field(key: "hasExportAssignment")]
+  property has_export_assignment : Bool?
+
+  @[JSON::Field(key: "isAbstract")]
+  property is_abstract : Bool?
+
+  @[JSON::Field(key: "isConst")]
+  property is_const : Bool?
+
+  @[JSON::Field(key: "isExported")]
+  property is_exported : Bool?
+
+  @[JSON::Field(key: "isLet")]
+  property is_let : Bool?
+
+  @[JSON::Field(key: "isPrivate")]
+  property is_private : Bool?
+
+  @[JSON::Field(key: "isProtected")]
+  property is_protected : Bool?
+end
+
+class StickySignature
+  include JSON::Serializable
+
+  property comment : StickyComment
+
+  property flags : IndigoFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property parameters : Array(TentacledParameter)?
+
+  @[JSON::Field(key: "type")]
+  property signature_type : CunningType
+
+  @[JSON::Field(key: "typeParameter")]
+  property type_parameter : Array(GetSignature)?
+end
+
+class TentacledParameter
+  include JSON::Serializable
+
+  property comment : TentacledComment?
+
+  @[JSON::Field(key: "defaultValue")]
+  property default_value : String?
+
+  property flags : TentacledFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  @[JSON::Field(key: "originalName")]
+  property original_name : String?
+
+  @[JSON::Field(key: "type")]
+  property parameter_type : AmbitiousType
+end
+
+class AmbitiousType
+  include JSON::Serializable
+
+  property declaration : TentacledDeclaration?
+
+  @[JSON::Field(key: "elementType")]
+  property element_type : ElementType?
+
+  property id : Int32?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(ElementType)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class TentacledDeclaration
+  include JSON::Serializable
+
+  property children : Array(IndigoChild)?
+
+  property flags : GetSignatureFlags
+
+  property groups : Array(Group)?
+
+  property id : Int32
+
+  @[JSON::Field(key: "indexSignature")]
+  property index_signature : IndexSignatureElement?
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property signatures : Array(GetSignature)?
+
+  property sources : Array(Source)
+end
+
+class IndigoChild
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property child_type : IndecentType
+
+  property comment : FluffyComment
+
+  @[JSON::Field(key: "defaultValue")]
+  property default_value : String?
+
+  property flags : FluffyFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  property sources : Array(Source)
+end
+
+class CunningType
+  include JSON::Serializable
+
+  property declaration : PurpleDeclaration?
+
+  property id : Int32?
+
+  property name : String?
+
+  @[JSON::Field(key: "typeArguments")]
+  property type_arguments : Array(ElementType)?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class TypeParameter
+  include JSON::Serializable
+
+  property comment : PurpleComment?
+
+  property flags : GetSignatureFlags
+
+  property id : Int32
+
+  property kind : Int32
+
+  @[JSON::Field(key: "kindString")]
+  property kind_string : String
+
+  property name : String
+
+  @[JSON::Field(key: "type")]
+  property type_parameter_type : MischievousType?
+end
+
+class MischievousType
+  include JSON::Serializable
+
+  property id : Int32?
+
+  property name : String?
+
+  property operator : String?
+
+  property target : ElementType?
+
+  @[JSON::Field(key: "type")]
+  property type_type : String
+end
+
+class IndecentComment
+  include JSON::Serializable
+
+  @[JSON::Field(key: "shortText")]
+  property short_text : String
+
+  property tags : Array(Tag)?
+end
diff --git a/head/crystal/test/inputs/json/priority/bug790.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug790.json/default/TopLevel.cr
new file mode 100644
index 0000000..f5490a1
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug790.json/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property children_data : Array(TopLevel)
+
+  property id : Int32
+
+  property is_active : Bool
+
+  property level : Int32
+
+  property name : String
+
+  property parent_id : Int32
+
+  property position : Int32
+
+  property product_count : Int32
+end
diff --git a/head/crystal/test/inputs/json/priority/bug855-short.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug855-short.json/default/TopLevel.cr
new file mode 100644
index 0000000..6098c97
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug855-short.json/default/TopLevel.cr
@@ -0,0 +1,17 @@
+require "json"
+
+alias TopLevel = Hash(String, TopLevelValue)
+
+class TopLevelValue
+  include JSON::Serializable
+
+  property channel_id : String
+
+  property channel_name : String
+
+  property code : String
+
+  property emoticon_set : Int32
+
+  property id : Int32
+end
diff --git a/head/crystal/test/inputs/json/priority/bug863.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/bug863.json/default/TopLevel.cr
new file mode 100644
index 0000000..ba4994c
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/bug863.json/default/TopLevel.cr
@@ -0,0 +1,169 @@
+require "json"
+
+alias TopLevel = Array(TopLevelUnion)
+
+class PurpleTopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "ALIENLEVEL")]
+  property alienlevel : Int32
+
+  @[JSON::Field(key: "BREED")]
+  property breed : String
+
+  @[JSON::Field(key: "CHAR_DIMENSION")]
+  property char_dimension : Int32
+
+  @[JSON::Field(key: "CHAR_INSTANCE")]
+  property char_instance : Int32
+
+  @[JSON::Field(key: "DEFENDER_RANK_TITLE")]
+  property defender_rank_title : String
+
+  @[JSON::Field(key: "FIRSTNAME")]
+  property firstname : String
+
+  @[JSON::Field(key: "HEADID")]
+  property headid : Int32
+
+  @[JSON::Field(key: "LASTNAME")]
+  property lastname : String
+
+  @[JSON::Field(key: "LEVELX")]
+  property levelx : Int32
+
+  @[JSON::Field(key: "NAME")]
+  property name : String
+
+  @[JSON::Field(key: "PROF")]
+  property prof : String
+
+  @[JSON::Field(key: "PROF_TITLE")]
+  property prof_title : String
+
+  @[JSON::Field(key: "PVPRATING")]
+  property pvprating : Int32
+
+  @[JSON::Field(key: "PVPTITLE")]
+  property pvptitle : String
+
+  @[JSON::Field(key: "RANK")]
+  property rank : Int32
+
+  @[JSON::Field(key: "RANK_TITLE")]
+  property rank_title : String
+
+  @[JSON::Field(key: "SEX")]
+  property sex : String
+end
+
+class FluffyTopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "ADVENTURERCOUNT")]
+  property adventurercount : Int32
+
+  @[JSON::Field(key: "AGENTCOUNT")]
+  property agentcount : Int32
+
+  @[JSON::Field(key: "ATROXCOUNT")]
+  property atroxcount : Int32
+
+  @[JSON::Field(key: "AVGLVL")]
+  property avglvl : Float64
+
+  @[JSON::Field(key: "BTCOUNT")]
+  property btcount : Int32
+
+  @[JSON::Field(key: "DESCRIPTION")]
+  property description : String
+
+  @[JSON::Field(key: "DOCTORCOUNT")]
+  property doctorcount : Int32
+
+  @[JSON::Field(key: "ENFCOUNT")]
+  property enfcount : Int32
+
+  @[JSON::Field(key: "ENGINEEERCOUNT")]
+  property engineeercount : Int32
+
+  @[JSON::Field(key: "FEMALECOUNT")]
+  property femalecount : Int32
+
+  @[JSON::Field(key: "FIXERCOUNT")]
+  property fixercount : Int32
+
+  @[JSON::Field(key: "GOVERNINGNAME")]
+  property governingname : String
+
+  @[JSON::Field(key: "HISTORY")]
+  property history : String
+
+  @[JSON::Field(key: "KEEPERCOUNT")]
+  property keepercount : Int32
+
+  @[JSON::Field(key: "MACOUNT")]
+  property macount : Int32
+
+  @[JSON::Field(key: "MALECOUNT")]
+  property malecount : Int32
+
+  @[JSON::Field(key: "MAXLVL")]
+  property maxlvl : Int32
+
+  @[JSON::Field(key: "METACOUNT")]
+  property metacount : Int32
+
+  @[JSON::Field(key: "MINLVL")]
+  property minlvl : Int32
+
+  @[JSON::Field(key: "MONSTERCOUNT")]
+  property monstercount : Int32
+
+  @[JSON::Field(key: "NAME")]
+  property name : String
+
+  @[JSON::Field(key: "NANOCOUNT")]
+  property nanocount : Int32
+
+  @[JSON::Field(key: "NANORACECOUNT")]
+  property nanoracecount : Int32
+
+  @[JSON::Field(key: "NEUTERCOUNT")]
+  property neutercount : Int32
+
+  @[JSON::Field(key: "NUMMEMBERS")]
+  property nummembers : Int32
+
+  @[JSON::Field(key: "OBJECTIVE")]
+  property objective : String
+
+  @[JSON::Field(key: "OPIFEXCOUNT")]
+  property opifexcount : Int32
+
+  @[JSON::Field(key: "ORG_DIMENSION")]
+  property org_dimension : Int32
+
+  @[JSON::Field(key: "ORG_INSTANCE")]
+  property org_instance : Int32
+
+  @[JSON::Field(key: "SHADECOUNT")]
+  property shadecount : Int32
+
+  @[JSON::Field(key: "SIDE")]
+  property side : Int32
+
+  @[JSON::Field(key: "SIDE_NAME")]
+  property side_name : String
+
+  @[JSON::Field(key: "SOLIDERCOUNT")]
+  property solidercount : Int32
+
+  @[JSON::Field(key: "SOLITUSCOUNT")]
+  property solituscount : Int32
+
+  @[JSON::Field(key: "TRADERCOUNT")]
+  property tradercount : Int32
+end
+
+alias TopLevelUnion = FluffyTopLevel | String | Array(PurpleTopLevel)
diff --git a/head/crystal/test/inputs/json/priority/coin-pairs.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/coin-pairs.json/default/TopLevel.cr
new file mode 100644
index 0000000..ad1c052
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/coin-pairs.json/default/TopLevel.cr
@@ -0,0 +1,29 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property pairs : Hash(String, Pair)
+
+  property server_time : Int32
+end
+
+class Pair
+  include JSON::Serializable
+
+  property decimal_places : Int32
+
+  property fee : Float64
+
+  property hidden : Int32
+
+  property max_amount : Int32
+
+  property max_price : Int32
+
+  property min_amount : Float64
+
+  property min_price : Float64
+
+  property min_total : Float64
+end
diff --git a/head/crystal/test/inputs/json/priority/combinations1.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/combinations1.json/default/TopLevel.cr
new file mode 100644
index 0000000..a49224e
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/combinations1.json/default/TopLevel.cr
@@ -0,0 +1,731 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property centrodesmose : String
+
+  property cerograph : Array(CerographElement?)
+
+  property chemotherapeutics : Array(ChemotherapeuticElement)
+
+  property cimelia : Array(CimeliaElement?)
+
+  property citrated : Int32
+
+  property clinodome : Array(Clinodome)
+
+  property coadjust : Array(CoadjustElement)
+
+  property consilience : Array(Consilience)
+
+  property constructor : Array(Constructor)
+
+  property continuative : Array(Continuative)
+
+  property credulity : Array(CredulityElement)
+
+  property creviced : Array(Creviced)
+
+  property cubiculum : Array(Array(Int32?))
+
+  property deruralize : Array(DeruralizeElement)
+
+  property diaereses : Array(DiaereseElement)
+
+  property dissolution : Array(Array(Nil)?)
+
+  property downstroke : Array(Downstroke)
+
+  property electrotautomerism : Array(Float64?)
+
+  property eleutheromania : Array(Eleutheromania)
+
+  property encrust : Encrust
+
+  property entomoid : Array(Entomoid)
+
+  property epipaleolithic : Array(Epipaleolithic)
+
+  property expropriable : Array(Expropriable)
+
+  property faggingly : Array(FagginglyElement)
+
+  property fenks : Array(FenkElement)
+
+  property flagmaking : Array(FlagmakingElement)
+
+  property fluorometer : Array(Fluorometer?)
+
+  property fulsome : Array(Int32?)
+
+  property fuzzy : Array(Fuzzy)
+
+  property gardenwards : Array(Gardenward)
+
+  property generalissimo : Array(Generalissimo?)
+
+  property habeas : Array(Hash(String, Int32)?)
+
+  property hemicrystalline : Array(Hemicrystalline)
+
+  property hemocoele : Array(HemocoeleElement)
+
+  property hoister : Array(Hoister?)
+
+  property hyperpiesis : Array(Hyperpiesi?)
+
+  property hyppish : Array(Hyppish?)
+
+  property idealizer : Array(Idealizer)
+
+  property incrustator : Array(Incrustator)
+
+  property intentiveness : Array(Intentiveness)
+
+  property interacinar : Interacinar
+
+  property intercorrelation : Array(Array(Int32)?)
+
+  property jacutinga : Array(Jacutinga)
+end
+
+class CerographClass
+  include JSON::Serializable
+
+  property apotropaion : Nil
+
+  property casuary : Nil
+
+  property creaker : Nil
+
+  property disqualification : Nil
+
+  property imperatorious : Nil
+
+  property impermeabilize : Nil
+
+  property metastoma : Nil
+
+  property noctidiurnal : Nil
+
+  property nonreserve : Nil
+
+  property ophthalmotonometry : Nil
+
+  property pailful : Nil
+
+  property pigfish : Nil
+
+  property pongee : Nil
+
+  property prosodical : Nil
+
+  property scrofuloderm : Nil
+
+  property storekeeping : Nil
+
+  property therologist : Nil
+
+  @[JSON::Field(key: "Tolowa")]
+  property tolowa : Nil
+
+  property tradeful : Nil
+
+  property unriveting : Nil
+end
+
+class ChemotherapeuticClass
+  include JSON::Serializable
+
+  property angioneurotic : Nil
+
+  property availment : Nil
+
+  property bladelet : Nil
+
+  property catharticalness : Float64?
+
+  property caulis : Nil
+
+  property chalcus : Nil
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property disdiapason : String?
+
+  property enteradenological : Nil
+
+  property homocerc : Bool?
+
+  property imporosity : Nil
+
+  property insistently : Nil
+
+  property intraparietal : Nil
+
+  property ivied : Nil
+
+  @[JSON::Field(key: "Maureen")]
+  property maureen : Nil
+
+  property nonbookish : Nil
+
+  property nostochine : Nil
+
+  property nutcracker : Nil
+
+  property ofttimes : Nil
+
+  property phenocryst : Nil
+
+  property precoincident : Nil
+
+  property ramiferous : Nil
+
+  property stagmometer : Nil
+
+  property tetherball : Nil
+
+  property unshy : Nil
+end
+
+class CimeliaClass
+  include JSON::Serializable
+
+  property catharticalness : Float64
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32
+
+  property disdiapason : String
+
+  property homocerc : Bool
+
+  property nonbookish : Nil
+end
+
+class CoadjustClass
+  include JSON::Serializable
+
+  property amidosulphonal : Nil
+
+  @[JSON::Field(key: "Benny")]
+  property benny : Nil
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property disdiapason : String?
+
+  property ensnare : Nil
+
+  property homocerc : Bool?
+
+  property hybridizer : Nil
+
+  property leastwise : Nil
+
+  property lof : Nil
+
+  property monkhood : Nil
+
+  @[JSON::Field(key: "Netherlandish")]
+  property netherlandish : Nil
+
+  property nonbookish : Nil
+
+  property peonism : Nil
+
+  @[JSON::Field(key: "Phonelescope")]
+  property phonelescope : Nil
+
+  property porphyrogeniture : Nil
+
+  property preindemnify : Nil
+
+  property rosal : Nil
+
+  property scalenous : Nil
+
+  property scopine : Nil
+
+  @[JSON::Field(key: "Sedaceae")]
+  property sedaceae : Nil
+
+  property suberinize : Nil
+
+  property symbiot : Nil
+
+  property tablefellow : Nil
+
+  property unchargeable : Nil
+end
+
+class CredulityClass
+  include JSON::Serializable
+
+  property ammonolytic : Nil
+
+  property bushmaster : Nil
+
+  property considering : Nil
+
+  property consuetudinary : Nil
+
+  property embarras : Nil
+
+  property fineness : Nil
+
+  property flaithship : Nil
+
+  @[JSON::Field(key: "Flavia")]
+  property flavia : Nil
+
+  property gruffly : Nil
+
+  @[JSON::Field(key: "Hedychium")]
+  property hedychium : Nil
+
+  property leadwort : Nil
+
+  property overseriously : Nil
+
+  property parabola : Nil
+
+  property pectinatodenticulate : Nil
+
+  @[JSON::Field(key: "Popean")]
+  property popean : Nil
+
+  property pornocrat : Nil
+
+  property quadrisect : Nil
+
+  property seriality : Nil
+
+  property vamphorn : Nil
+
+  property wharp : Nil
+end
+
+class DeruralizeClass
+  include JSON::Serializable
+
+  property bockerel : Nil
+
+  property boulder : Nil
+
+  property churrus : Nil
+
+  property counterdigged : Nil
+
+  property dialogite : Nil
+
+  property digenic : Nil
+
+  property dunbird : Nil
+
+  property ergatogyne : Nil
+
+  property fiendful : Nil
+
+  property jackrod : Nil
+
+  @[JSON::Field(key: "Jehovistic")]
+  property jehovistic : Nil
+
+  @[JSON::Field(key: "Paninean")]
+  property paninean : Nil
+
+  property panther : Nil
+
+  property placentigerous : Nil
+
+  @[JSON::Field(key: "Romney")]
+  property romney : Nil
+
+  property sparm : Nil
+
+  property tocsin : Nil
+
+  property unnicked : Nil
+
+  property unstavable : Nil
+
+  property windfirm : Nil
+end
+
+class DiaereseClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Amoreuxia")]
+  property amoreuxia : Nil
+
+  property ani : Nil
+
+  property bernicle : Nil
+
+  property blackwasher : Nil
+
+  property blowhard : Nil
+
+  property broma : Nil
+
+  property closecross : Nil
+
+  property congregationalism : Nil
+
+  property grayly : Nil
+
+  property historically : Nil
+
+  property hoast : Nil
+
+  property irretentive : Nil
+
+  property parcener : Nil
+
+  property pedder : Nil
+
+  property pseudoanatomic : Nil
+
+  property rhizocarpian : Nil
+
+  property samel : Nil
+
+  property silker : Nil
+
+  property subdentated : Nil
+
+  property subobscure : Nil
+end
+
+class Encrust
+  include JSON::Serializable
+
+  property comradely : Nil
+
+  property diacanthous : Nil
+
+  property feminineness : Nil
+
+  property gossamered : Nil
+
+  @[JSON::Field(key: "Hibernia")]
+  property hibernia : Nil
+
+  @[JSON::Field(key: "Hibiscus")]
+  property hibiscus : Nil
+
+  @[JSON::Field(key: "Lepidosauria")]
+  property lepidosauria : Nil
+
+  property lollingly : Nil
+
+  property manager : Nil
+
+  property mechanic : Nil
+
+  property overminuteness : Nil
+
+  property papelonne : Nil
+
+  property plebification : Nil
+
+  property pugmiller : Nil
+
+  property recoveror : Nil
+
+  property spermatoblastic : Nil
+
+  @[JSON::Field(key: "Syllidae")]
+  property syllidae : Nil
+
+  property ungyved : Nil
+
+  property whirlabout : Nil
+
+  property woodenware : Nil
+end
+
+class FagginglyClass
+  include JSON::Serializable
+
+  property abranchian : Nil
+
+  property aculeiform : Nil
+
+  property adiaphoristic : Nil
+
+  property adoptionism : Nil
+
+  @[JSON::Field(key: "Anglic")]
+  property anglic : Nil
+
+  property antrotomy : Nil
+
+  property coerciveness : Nil
+
+  property decorist : Nil
+
+  property duckhood : Nil
+
+  @[JSON::Field(key: "Heteromeri")]
+  property heteromeri : Nil
+
+  property hypochnose : Nil
+
+  property lochage : Nil
+
+  property melee : Nil
+
+  property nonconformitant : Nil
+
+  @[JSON::Field(key: "Poinsettia")]
+  property poinsettia : Nil
+
+  property putatively : Nil
+
+  property semivolatile : Nil
+
+  property soleas : Nil
+
+  property unfastenable : Nil
+
+  property unmillinered : Nil
+end
+
+class FenkClass
+  include JSON::Serializable
+
+  property apoise : Nil
+
+  property astronomize : Nil
+
+  property cockhorse : Nil
+
+  property copular : Nil
+
+  @[JSON::Field(key: "Dagomba")]
+  property dagomba : Nil
+
+  property draffy : Nil
+
+  property foreigner : Nil
+
+  @[JSON::Field(key: "Guyandot")]
+  property guyandot : Nil
+
+  property neurogliosis : Nil
+
+  property osmious : Nil
+
+  property palpitate : Nil
+
+  property rebukeable : Nil
+
+  @[JSON::Field(key: "Reinwardtia")]
+  property reinwardtia : Nil
+
+  property reservatory : Nil
+
+  property scalt : Nil
+
+  property scripturalize : Nil
+
+  property tintometer : Nil
+
+  @[JSON::Field(key: "Tritoness")]
+  property tritoness : Nil
+
+  property undergrade : Nil
+
+  property undermountain : Nil
+end
+
+class FlagmakingClass
+  include JSON::Serializable
+
+  property albarco : Nil
+
+  @[JSON::Field(key: "Bunodonta")]
+  property bunodonta : Nil
+
+  property hornify : Nil
+
+  @[JSON::Field(key: "Hydrocorisae")]
+  property hydrocorisae : Nil
+
+  property hypoglossus : Nil
+
+  property inexpiably : Nil
+
+  property ingratitude : Nil
+
+  property ladyfly : Nil
+
+  property medicament : Nil
+
+  property monogrammatic : Nil
+
+  property nobbut : Nil
+
+  @[JSON::Field(key: "Notacanthidae")]
+  property notacanthidae : Nil
+
+  property polyplacophore : Nil
+
+  property proexercise : Nil
+
+  property protoplast : Nil
+
+  property puzzling : Nil
+
+  property splanchnoskeleton : Nil
+
+  property unloveliness : Nil
+
+  property unquarantined : Nil
+
+  property unrenounceable : Nil
+end
+
+class HemocoeleClass
+  include JSON::Serializable
+
+  property acrogamy : Nil
+
+  property amelification : Nil
+
+  property autobiographic : Nil
+
+  property berat : Nil
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property disdiapason : String?
+
+  property disproportionably : Nil
+
+  property erythrite : Nil
+
+  property graphic : Nil
+
+  property hepatological : Nil
+
+  property homocerc : Bool?
+
+  property incommensurably : Nil
+
+  property misaffirm : Nil
+
+  property nonbookish : Nil
+
+  property pocketbook : Nil
+
+  property sclerometric : Nil
+
+  property stambouline : Nil
+
+  property stickpin : Nil
+
+  property tubulure : Nil
+
+  property undelated : Nil
+
+  property unsalt : Nil
+
+  property untutelar : Nil
+
+  property vagrant : Nil
+
+  @[JSON::Field(key: "Walt")]
+  property walt : Nil
+end
+
+class Interacinar
+  include JSON::Serializable
+
+  property assapan : Float64
+
+  property benefactorship : Bool
+
+  property triseriatim : String
+
+  property tubbing : Int32
+
+  property untrimmed : Nil
+end
+
+alias CerographElement = CerographClass | String
+
+alias ChemotherapeuticElement = ChemotherapeuticClass | Int32
+
+alias CimeliaElement = CimeliaClass | Array(Int32)
+
+alias Clinodome = Float64 | String
+
+alias CoadjustElement = CoadjustClass | Float64
+
+alias Consilience = Float64 | Hash(String, Int32)
+
+alias Constructor = Bool | Hash(String, Int32?)
+
+alias Continuative = Hash(String, Int32) | String
+
+alias CredulityElement = CredulityClass | Int32 | String
+
+alias Creviced = Hash(String, Int32) | Bool | String
+
+alias DeruralizeElement = DeruralizeClass | Array(Nil) | Bool
+
+alias DiaereseElement = DiaereseClass | Array(Int32) | Bool
+
+alias Downstroke = Array(Nil) | Bool | String
+
+alias Eleutheromania = Float64 | Hash(String, Int32) | String
+
+alias Entomoid = CimeliaClass | Int32
+
+alias Epipaleolithic = Float64 | Array(Int32)
+
+alias Expropriable = CimeliaClass | Float64 | Array(Nil)
+
+alias FagginglyElement = Float64 | FagginglyClass
+
+alias FenkElement = FenkClass | String
+
+alias FlagmakingElement = Float64 | FlagmakingClass | Bool
+
+alias Fluorometer = Int32 | String
+
+alias Fuzzy = Int32 | Hash(String, Int32?)
+
+alias Gardenward = Array(Int32) | Bool | String
+
+alias Generalissimo = Hash(String, Int32) | Bool
+
+alias Hemicrystalline = CimeliaClass | String
+
+alias HemocoeleElement = HemocoeleClass | Array(Int32)
+
+alias Hoister = CimeliaClass | String
+
+alias Hyperpiesi = CimeliaClass | Array(Nil)
+
+alias Hyppish = Bool | String
+
+alias Idealizer = CimeliaClass | Int32 | Array(Nil)
+
+alias Incrustator = Int32 | Array(Int32) | String
+
+alias Intentiveness = CimeliaClass | Float64 | String
+
+alias Jacutinga = Array(Int32) | Hash(String, Int32?)
diff --git a/head/crystal/test/inputs/json/priority/combinations2.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/combinations2.json/default/TopLevel.cr
new file mode 100644
index 0000000..a5b6587
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/combinations2.json/default/TopLevel.cr
@@ -0,0 +1,650 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Abranchiata")]
+  property abranchiata : Array(Abranchiata?)
+
+  property academe : Array(Academe)
+
+  property acquirable : Array(Acquirable)
+
+  property aerometry : Array(Aerometry)
+
+  property alexin : Array(Alexin)
+
+  property alleviate : Array(AlleviateElement)
+
+  property amaas : Array(Amaa)
+
+  property ambassage : Array(Ambassage)
+
+  property amphithyron : Array(Amphithyron?)
+
+  @[JSON::Field(key: "Andriana")]
+  property andriana : Array(String?)
+
+  property ankee : Array(AnkeeElement)
+
+  property annihilator : Array(Hash(String, Int32?)?)
+
+  property annulose : Nil
+
+  @[JSON::Field(key: "Ansarie")]
+  property ansarie : Array(AnsarieElement?)
+
+  property aphasia : Array(Aphasia)
+
+  property asprawl : Array(Asprawl)
+
+  property attractive : Array(Bool?)
+
+  property barksome : Hash(String, Int32)
+
+  property bedesman : Array(Bedesman)
+
+  property belard : Array(Belard)
+
+  property bocking : Array(Bocking)
+
+  property brawlingly : Array(Brawlingly)
+
+  property brookie : Array(Brookie)
+
+  property bumboatman : Array(Bumboatman?)
+
+  property bystreet : Array(Nil)
+
+  property calaverite : Array(Calaverite)
+
+  property catallactic : Array(Catallactic)
+
+  property cemental : Array(Cemental)
+
+  @[JSON::Field(key: "Chytridiaceae")]
+  property chytridiaceae : Array(ChytridiaceaeElement?)
+
+  @[JSON::Field(key: "Discordia")]
+  property discordia : Array(DiscordiaElement)
+
+  @[JSON::Field(key: "Endomyces")]
+  property endomyces : Array(Endomyce)
+
+  @[JSON::Field(key: "Epinephelidae")]
+  property epinephelidae : Array(Epinephelidae)
+
+  @[JSON::Field(key: "Eupatorium")]
+  property eupatorium : Array(Eupatorium)
+
+  @[JSON::Field(key: "Gryphosaurus")]
+  property gryphosaurus : Array(GryphosaurusElement)
+
+  @[JSON::Field(key: "Koryak")]
+  property koryak : Array(Koryak)
+
+  @[JSON::Field(key: "Lavinia")]
+  property lavinia : Array(LaviniaElement)
+
+  @[JSON::Field(key: "Oskar")]
+  property oskar : Array(OskarElement)
+
+  @[JSON::Field(key: "Rebecca")]
+  property rebecca : Array(RebeccaElement)
+
+  @[JSON::Field(key: "Rhomboganoidei")]
+  property rhomboganoidei : Array(Rhomboganoidei)
+
+  @[JSON::Field(key: "Rigsmal")]
+  property rigsmal : Bool
+
+  @[JSON::Field(key: "Ruellia")]
+  property ruellia : Array(Ruellia)
+
+  @[JSON::Field(key: "School")]
+  property school : Array(School?)
+
+  @[JSON::Field(key: "Shakespearolater")]
+  property shakespearolater : Array(Shakespearolater)
+
+  @[JSON::Field(key: "Svan")]
+  property svan : Array(Float64)
+
+  @[JSON::Field(key: "Wayao")]
+  property wayao : Hash(String, Float64)
+end
+
+class AlleviateClass
+  include JSON::Serializable
+
+  property apriori : Nil
+
+  property beggarer : Nil
+
+  property brokenheartedly : Nil
+
+  property debilitation : Nil
+
+  property frike : Nil
+
+  property gastrolith : Nil
+
+  @[JSON::Field(key: "Hulsean")]
+  property hulsean : Nil
+
+  property orthocentric : Nil
+
+  property petaly : Nil
+
+  property probudgeting : Nil
+
+  property reacquire : Nil
+
+  property scow : Nil
+
+  property shutoff : Nil
+
+  property subcontiguous : Nil
+
+  property suffumigate : Nil
+
+  property transformable : Nil
+
+  property uncoroneted : Nil
+
+  property unparking : Nil
+
+  property unvarnishedness : Nil
+
+  property wherewithal : Nil
+end
+
+class Rebecca
+  include JSON::Serializable
+
+  property catharticalness : Float64
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32
+
+  property disdiapason : String
+
+  property homocerc : Bool
+
+  property nonbookish : Nil
+end
+
+class Amphithyron
+  include JSON::Serializable
+
+  property akroasis : Int32?
+
+  property antiphonical : Int32?
+
+  property basebred : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property conductometric : Int32?
+
+  property disdiapason : String?
+
+  property ensilation : Int32?
+
+  property eyebolt : Int32?
+
+  property fistulated : Int32?
+
+  property heteropod : Int32?
+
+  property homocerc : Bool?
+
+  @[JSON::Field(key: "Juniperus")]
+  property juniperus : Int32?
+
+  property labyrinthically : Int32?
+
+  property martyrization : Int32?
+
+  property mispolicy : Int32?
+
+  property multipara : Int32?
+
+  @[JSON::Field(key: "Nazirite")]
+  property nazirite : Int32?
+
+  property nonbookish : Nil
+
+  property possessorial : Int32?
+
+  property shamed : Int32?
+
+  property shelfworn : Int32?
+
+  property stagnum : Int32?
+
+  @[JSON::Field(key: "Those")]
+  property those : Int32?
+
+  property undecimal : Int32?
+end
+
+class AnkeeClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Anomoean")]
+  property anomoean : Nil
+
+  property barleyhood : Nil
+
+  property befriender : Nil
+
+  property brutishness : Nil
+
+  property cephalalgy : Nil
+
+  property cirurgian : Nil
+
+  property conventionally : Nil
+
+  property jackshay : Nil
+
+  property milammeter : Nil
+
+  @[JSON::Field(key: "Naja")]
+  property naja : Nil
+
+  property ombrological : Nil
+
+  property phonasthenia : Nil
+
+  property retrievableness : Nil
+
+  property snakily : Nil
+
+  property swot : Nil
+
+  property tartlet : Nil
+
+  property thiofuran : Nil
+
+  property tracheophone : Nil
+
+  property tuglike : Nil
+
+  property unscratchingly : Nil
+end
+
+class AnsarieClass
+  include JSON::Serializable
+
+  property accension : Nil
+
+  @[JSON::Field(key: "Alida")]
+  property alida : Nil
+
+  property asteria : Nil
+
+  property beriberic : Nil
+
+  property edgebone : Nil
+
+  property gastrodialysis : Nil
+
+  property geographic : Nil
+
+  @[JSON::Field(key: "Ictonyx")]
+  property ictonyx : Nil
+
+  property metrocele : Nil
+
+  property misgraft : Nil
+
+  property monteith : Nil
+
+  property notcher : Nil
+
+  property prorestriction : Nil
+
+  @[JSON::Field(key: "Ramist")]
+  property ramist : Nil
+
+  property throatlet : Nil
+
+  property unfair : Nil
+
+  property unsynonymous : Nil
+
+  property water : Nil
+
+  property zestfully : Nil
+
+  property zincic : Nil
+end
+
+class ChytridiaceaeClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Batidaceae")]
+  property batidaceae : Nil
+
+  @[JSON::Field(key: "Brechites")]
+  property brechites : Nil
+
+  property codespairer : Nil
+
+  @[JSON::Field(key: "Emery")]
+  property emery : Nil
+
+  property enervative : Nil
+
+  property excriminate : Nil
+
+  property goshenite : Nil
+
+  property grime : Nil
+
+  property gritten : Nil
+
+  property hectorly : Nil
+
+  property intermediation : Nil
+
+  property meeterly : Nil
+
+  @[JSON::Field(key: "Narraganset")]
+  property narraganset : Nil
+
+  property onymatic : Nil
+
+  property paddlecock : Nil
+
+  property thana : Nil
+
+  property thornily : Nil
+
+  property uckia : Nil
+
+  property unmettle : Nil
+
+  property vorticellid : Nil
+end
+
+class DiscordiaClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Altaic")]
+  property altaic : Int32?
+
+  property amoristic : Int32?
+
+  property blennophthalmia : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property disciplinability : Int32?
+
+  property disdiapason : String?
+
+  property goofer : Int32?
+
+  property homocerc : Bool?
+
+  property laryngograph : Int32?
+
+  property leucitis : Int32?
+
+  property lymphocyst : Int32?
+
+  property microcosmology : Int32?
+
+  property nauseation : Int32?
+
+  property nonbookish : Nil
+
+  @[JSON::Field(key: "Patarin")]
+  property patarin : Int32?
+
+  property preliberal : Int32?
+
+  property prettifier : Int32?
+
+  property rangework : Int32?
+
+  property redient : Int32?
+
+  property subfusiform : Int32?
+
+  property suicidical : Int32?
+
+  property swow : Int32?
+
+  property wastrel : Int32?
+
+  property wingle : Int32?
+end
+
+class GryphosaurusClass
+  include JSON::Serializable
+
+  property amissibility : Nil
+
+  @[JSON::Field(key: "Burushaski")]
+  property burushaski : Nil
+
+  property citronin : Nil
+
+  property coplaintiff : Nil
+
+  property disquisitionary : Nil
+
+  property enoplan : Nil
+
+  property faintness : Nil
+
+  property hebetomy : Nil
+
+  property islandry : Nil
+
+  property lameduck : Nil
+
+  property overbattle : Nil
+
+  property overinterested : Nil
+
+  property phrenologic : Nil
+
+  property rainband : Nil
+
+  property shiningly : Nil
+
+  property stamineous : Nil
+
+  property subscapularis : Nil
+
+  @[JSON::Field(key: "Tahami")]
+  property tahami : Nil
+
+  property undaubed : Nil
+
+  property underntime : Nil
+end
+
+class LaviniaClass
+  include JSON::Serializable
+
+  property agitable : Int32?
+
+  property asininity : Int32?
+
+  property benefiter : Int32?
+
+  property bronzelike : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property cholesteatomatous : Int32?
+
+  property deprivement : Int32?
+
+  property disdiapason : String?
+
+  property flippantness : Int32?
+
+  property fogproof : Int32?
+
+  property homocerc : Bool?
+
+  property merrymeeting : Int32?
+
+  property nonbookish : Nil
+
+  property overcareful : Int32?
+
+  property panaris : Int32?
+
+  property preacceptance : Int32?
+
+  property quinoxaline : Int32?
+
+  property sig : Int32?
+
+  property superconfusion : Int32?
+
+  @[JSON::Field(key: "Tacana")]
+  property tacana : Int32?
+
+  property tillotter : Int32?
+
+  property tranquillize : Int32?
+
+  property unquestionable : Int32?
+
+  property uproute : Int32?
+end
+
+class OskarClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Acrobates")]
+  property acrobates : Nil
+
+  property beanshooter : Nil
+
+  property bearhound : Nil
+
+  @[JSON::Field(key: "Cayuga")]
+  property cayuga : Nil
+
+  property guarneri : Nil
+
+  property hypochondriacism : Nil
+
+  property indication : Nil
+
+  property jaculative : Nil
+
+  property nagana : Nil
+
+  @[JSON::Field(key: "Netherlandish")]
+  property netherlandish : Nil
+
+  property noctivagous : Nil
+
+  property nonphysiological : Nil
+
+  property praxis : Nil
+
+  property provision : Nil
+
+  property subterhuman : Nil
+
+  property sunlit : Nil
+
+  property syncraniate : Nil
+
+  property teachment : Nil
+
+  property unmutinous : Nil
+
+  property unstoppable : Nil
+end
+
+alias Abranchiata = Int32 | Array(Int32)
+
+alias Academe = Int32 | Array(Int32) | Hash(String, Int32)
+
+alias Acquirable = Hash(String, Int32) | Array(Int32?)
+
+alias Aerometry = Float64 | Bool
+
+alias Alexin = Array(Int32) | Bool
+
+alias AlleviateElement = AlleviateClass | Array(Int32?)
+
+alias Amaa = Int32 | Bool | Rebecca
+
+alias Ambassage = Array(Nil) | String
+
+alias AnkeeElement = AnkeeClass | Int32 | Array(Int32)
+
+alias AnsarieElement = AnsarieClass | Array(Int32)
+
+alias Aphasia = Int32 | Array(Int32)
+
+alias Asprawl = Float64 | String
+
+alias Bedesman = Float64 | Bool | String
+
+alias Belard = Float64 | Array(Int32) | Rebecca
+
+alias Bocking = Array(Int32) | Hash(String, Int32) | Bool
+
+alias Brawlingly = Array(Nil) | Hash(String, Int32?)
+
+alias Brookie = Array(Int32) | Rebecca
+
+alias Bumboatman = Array(Nil) | String
+
+alias Calaverite = Array(Int32) | String
+
+alias Catallactic = Hash(String, Int32) | Array(Nil) | Bool
+
+alias Cemental = Float64 | Array(Int32) | Hash(String, Int32)
+
+alias ChytridiaceaeElement = ChytridiaceaeClass | Bool
+
+alias DiscordiaElement = DiscordiaClass | Array(Int32)
+
+alias Endomyce = Int32 | String
+
+alias Epinephelidae = Int32 | Bool | String
+
+alias Eupatorium = Hash(String, Int32) | Array(Nil)
+
+alias GryphosaurusElement = GryphosaurusClass | Array(Int32) | String
+
+alias Koryak = String | Hash(String, Int32?)
+
+alias LaviniaElement = LaviniaClass | String
+
+alias OskarElement = Array(Int32) | OskarClass
+
+alias RebeccaElement = Int32 | String | Rebecca
+
+alias Rhomboganoidei = Array(Int32) | String | Rebecca
+
+alias Ruellia = Bool | String | Rebecca
+
+alias School = Int32 | Hash(String, Int32)
+
+alias Shakespearolater = Float64 | Array(Int32) | String
diff --git a/head/crystal/test/inputs/json/priority/combinations3.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/combinations3.json/default/TopLevel.cr
new file mode 100644
index 0000000..616267f
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/combinations3.json/default/TopLevel.cr
@@ -0,0 +1,836 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property juror : Array(JurorElement)
+
+  property kongoni : Array(Kongoni)
+
+  property ladronism : Array(LadronismElement)
+
+  property landlubberly : Array(LandlubberlyElement)
+
+  property listener : Array(Listener)
+
+  property lupus : Array(LupusElement)
+
+  property maslin : Array(Maslin)
+
+  property monazite : Array(MonaziteElement)
+
+  property monoliteral : Array(Monoliteral)
+
+  property monotheistically : Array(MonotheisticallyElement)
+
+  property montage : Array(Montage)
+
+  property moralness : Array(Moralness?)
+
+  property mowra : Array(MonaziteClass?)
+
+  property mulishly : Array(Mulishly?)
+
+  property myoscope : Array(Myoscope)
+
+  property nach : Array(Array(Int32?)?)
+
+  property neuromastic : Array(Neuromastic)
+
+  property noncontributing : Array(Noncontributing)
+
+  property nonnervous : Array(Nonnervous)
+
+  property nonvaluation : Array(Nonvaluation)
+
+  property occupationalist : Array(OccupationalistElement?)
+
+  property outrival : Array(OutrivalElement?)
+
+  property paleographically : Array(Paleographically)
+
+  property pamphletwise : Array(Pamphletwise)
+
+  property pediatrics : Array(Pediatric?)
+
+  property perceptive : Array(Bool)
+
+  property piaculum : Array(PiaculumElement)
+
+  property piccadilly : Array(Piccadilly?)
+
+  property piffler : Array(Piffler)
+
+  property pithful : Array(Pithful?)
+
+  property placuntitis : Array(Placuntiti)
+
+  property plectopterous : Array(Plectopterous)
+
+  property pneumocele : Array(Pneumocele?)
+
+  property poliorcetic : Array(Poliorcetic)
+
+  property poormaster : Array(Poormaster?)
+
+  property potwhisky : Array(PotwhiskyElement?)
+
+  property practicalizer : Array(Practicalizer)
+
+  property prefreshman : Array(PrefreshmanElement)
+
+  property prehensility : Array(Prehensility)
+
+  property prevoidance : Array(Prevoidance)
+
+  property probant : Array(Hash(String, Int32?))
+
+  property protext : Array(Protext)
+end
+
+class JurorClass
+  include JSON::Serializable
+
+  property adipsy : Nil
+
+  property auxiliator : Nil
+
+  property benda : Nil
+
+  property benjamin : Nil
+
+  property brandling : Nil
+
+  property epicurishly : Nil
+
+  property eremochaetous : Nil
+
+  property marten : Nil
+
+  property monocline : Nil
+
+  @[JSON::Field(key: "Olea")]
+  property olea : Nil
+
+  property palgat : Nil
+
+  property pennyworth : Nil
+
+  property pioury : Nil
+
+  property pragmatistic : Nil
+
+  property stylelessness : Nil
+
+  property systematical : Nil
+
+  property thready : Nil
+
+  property uncontemporary : Nil
+
+  property uncouched : Nil
+
+  property uninhabitedness : Nil
+end
+
+class LadronismClass
+  include JSON::Serializable
+
+  property acclaimer : Nil
+
+  property achree : Nil
+
+  property base : Nil
+
+  property conundrumize : Nil
+
+  property degerminator : Nil
+
+  property describable : Nil
+
+  property exasperatedly : Nil
+
+  property heroine : Nil
+
+  property indazin : Nil
+
+  property luteous : Nil
+
+  property papular : Nil
+
+  property pritch : Nil
+
+  @[JSON::Field(key: "Prodenia")]
+  property prodenia : Nil
+
+  property seege : Nil
+
+  property shopgirl : Nil
+
+  property tragedietta : Nil
+
+  property unsparse : Nil
+
+  property uplook : Nil
+
+  property vermiformis : Nil
+
+  property whafabout : Nil
+end
+
+class LandlubberlyClass
+  include JSON::Serializable
+
+  property acropoleis : Nil
+
+  property aminate : Nil
+
+  @[JSON::Field(key: "Amyraldism")]
+  property amyraldism : Nil
+
+  property bipenniform : Nil
+
+  property bugre : Nil
+
+  property calycule : Nil
+
+  property caoutchouc : Nil
+
+  property disprover : Nil
+
+  property fitroot : Nil
+
+  property fulgently : Nil
+
+  property kickup : Nil
+
+  property laevoversion : Nil
+
+  property moter : Nil
+
+  property objectivity : Nil
+
+  property posterity : Nil
+
+  property postnuptial : Nil
+
+  property precedentary : Nil
+
+  property saddling : Nil
+
+  property subcurrent : Nil
+
+  property unrecriminative : Nil
+end
+
+class LupusClass
+  include JSON::Serializable
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  @[JSON::Field(key: "Chlorioninae")]
+  property chlorioninae : Int32?
+
+  @[JSON::Field(key: "Corvinae")]
+  property corvinae : Int32?
+
+  @[JSON::Field(key: "Crassina")]
+  property crassina : Int32?
+
+  property disdiapason : String?
+
+  property exiguity : Int32?
+
+  property farcist : Int32?
+
+  property holographical : Int32?
+
+  property homocerc : Bool?
+
+  property ichthyophagan : Int32?
+
+  property implacable : Int32?
+
+  property nonbookish : Nil
+
+  property outshiner : Int32?
+
+  property overweather : Int32?
+
+  property protonegroid : Int32?
+
+  property shallowish : Int32?
+
+  property snoke : Int32?
+
+  property snout : Int32?
+
+  property surveillance : Int32?
+
+  property threshingtime : Int32?
+
+  @[JSON::Field(key: "Thysanocarpus")]
+  property thysanocarpus : Int32?
+
+  property unsignificantly : Int32?
+
+  property unsnap : Int32?
+
+  property vendible : Int32?
+end
+
+class Maslin
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Alicant")]
+  property alicant : Int32?
+
+  property antiatonement : Nil
+
+  property anticorrosive : Int32?
+
+  property aphidozer : Nil
+
+  @[JSON::Field(key: "Bakuninist")]
+  property bakuninist : Nil
+
+  property be : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property chub : Int32?
+
+  property cuprosilicon : Int32?
+
+  property curtailedly : Int32?
+
+  property dellenite : Int32?
+
+  @[JSON::Field(key: "Dimitry")]
+  property dimitry : Int32?
+
+  property disdiapason : String?
+
+  property edifying : Nil
+
+  property ethmoiditis : Int32?
+
+  property gastralgy : Nil
+
+  property goatherd : Int32?
+
+  property hammerdress : Int32?
+
+  property hangfire : Nil
+
+  property homocerc : Bool?
+
+  property lacunosity : Int32?
+
+  property longiloquence : Nil
+
+  property mameliere : Int32?
+
+  property motherless : Nil
+
+  property nonbookish : Nil
+
+  property noncorrodible : Nil
+
+  property nonsensicality : Nil
+
+  property oafishly : Int32?
+
+  property pfund : Nil
+
+  property preadvisory : Nil
+
+  property retroflexed : Nil
+
+  property saccharulmic : Int32?
+
+  property scowlful : Int32?
+
+  property secluded : Nil
+
+  property slackage : Nil
+
+  property sphaeridial : Int32?
+
+  property spondulics : Nil
+
+  property subsecive : Int32?
+
+  property swellmobsman : Nil
+
+  property trachyglossate : Int32?
+
+  property trialogue : Nil
+
+  property unassuaged : Int32?
+
+  property ungross : Nil
+
+  property unjudiciously : Nil
+end
+
+class MonaziteClass
+  include JSON::Serializable
+
+  property catharticalness : Float64
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32
+
+  property disdiapason : String
+
+  property homocerc : Bool
+
+  property nonbookish : Nil
+end
+
+class MonotheisticallyClass
+  include JSON::Serializable
+
+  property blaspheme : Nil
+
+  property catharticalness : Float64?
+
+  property celiosalpingectomy : Nil
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property consummativeness : Nil
+
+  property disdiapason : String?
+
+  property egestive : Nil
+
+  property enchylema : Nil
+
+  property gasconade : Nil
+
+  property holidayer : Nil
+
+  property homocerc : Bool?
+
+  property intuitionalism : Nil
+
+  property lophiostomate : Nil
+
+  property nonbookish : Nil
+
+  property nonvolition : Nil
+
+  property palatableness : Nil
+
+  property pimpery : Nil
+
+  property previolation : Nil
+
+  property reconveyance : Nil
+
+  property registership : Nil
+
+  property rhyacolite : Nil
+
+  property smithereens : Nil
+
+  property superedification : Nil
+
+  property trust : Nil
+
+  property whitestone : Nil
+end
+
+class Noncontributing
+  include JSON::Serializable
+
+  property estevin : String
+
+  property jolterhead : Float64
+
+  property sauternes : Int32
+
+  property sparsely : Bool
+
+  property unrequested : Nil
+end
+
+class OccupationalistClass
+  include JSON::Serializable
+
+  property beholdable : Nil
+
+  property brotuliform : Nil
+
+  @[JSON::Field(key: "Chimakum")]
+  property chimakum : Nil
+
+  property doodler : Nil
+
+  property emulsin : Nil
+
+  @[JSON::Field(key: "Fin")]
+  property fin : Nil
+
+  property flourishing : Nil
+
+  property flueless : Nil
+
+  property furtively : Nil
+
+  property gritter : Nil
+
+  property interwish : Nil
+
+  property monoxylic : Nil
+
+  property myristic : Nil
+
+  property nightwear : Nil
+
+  property peruser : Nil
+
+  property theoastrological : Nil
+
+  property thumby : Nil
+
+  property tingitid : Nil
+
+  property trailless : Nil
+
+  property unpocketed : Nil
+end
+
+class OutrivalClass
+  include JSON::Serializable
+
+  property adroitly : Nil
+
+  property bridehood : Nil
+
+  @[JSON::Field(key: "Castoroides")]
+  property castoroides : Nil
+
+  @[JSON::Field(key: "Czechoslovak")]
+  property czechoslovak : Nil
+
+  property diagenesis : Nil
+
+  property dihexahedron : Nil
+
+  property dopester : Nil
+
+  property eumerism : Nil
+
+  property flyness : Nil
+
+  property fouler : Nil
+
+  property laudanosine : Nil
+
+  @[JSON::Field(key: "Lingulidae")]
+  property lingulidae : Nil
+
+  property minutary : Nil
+
+  property mitra : Nil
+
+  property opisthorchiasis : Nil
+
+  property pensively : Nil
+
+  property pubigerous : Nil
+
+  property rebellious : Nil
+
+  property recodify : Nil
+
+  property unpaced : Nil
+end
+
+class PiaculumClass
+  include JSON::Serializable
+
+  property alada : Int32?
+
+  property amphistomous : Int32?
+
+  property boysenberry : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property decardinalize : Int32?
+
+  property discouragement : Int32?
+
+  property disdiapason : String?
+
+  property doitrified : Int32?
+
+  property hexaspermous : Int32?
+
+  property homocerc : Bool?
+
+  property insinking : Int32?
+
+  property loathfulness : Int32?
+
+  property miasmatical : Int32?
+
+  property neurofibril : Int32?
+
+  property nonbookish : Nil
+
+  property phonendoscope : Int32?
+
+  property pilferment : Int32?
+
+  property predismissory : Int32?
+
+  property preinscription : Int32?
+
+  property quotative : Int32?
+
+  property sienna : Int32?
+
+  property thorax : Int32?
+
+  property yachting : Int32?
+
+  @[JSON::Field(key: "Zipper")]
+  property zipper : Int32?
+end
+
+class Pneumocele
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Carbonarism")]
+  property carbonarism : Nil
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property cineolic : Nil
+
+  property cobbly : Nil
+
+  property conchyliferous : Nil
+
+  property congregation : Nil
+
+  property disdiapason : String?
+
+  property enterotomy : Nil
+
+  property entophytal : Nil
+
+  property fewtrils : Nil
+
+  property herem : Nil
+
+  property homocerc : Bool?
+
+  @[JSON::Field(key: "Koniga")]
+  property koniga : Nil
+
+  property meticulosity : Nil
+
+  @[JSON::Field(key: "Micky")]
+  property micky : Nil
+
+  property mismarriage : Nil
+
+  property neurotrophic : Nil
+
+  property nonbookish : Nil
+
+  property persuasively : Nil
+
+  property replaceable : Nil
+
+  property silex : Nil
+
+  property taillight : Nil
+
+  property unjealous : Nil
+
+  property visitorial : Nil
+end
+
+class PotwhiskyClass
+  include JSON::Serializable
+
+  property arciform : Nil
+
+  property cresolin : Nil
+
+  property disheartener : Nil
+
+  property disproportionable : Nil
+
+  @[JSON::Field(key: "Euchorda")]
+  property euchorda : Nil
+
+  property ferryway : Nil
+
+  property filamentiferous : Nil
+
+  property flemish : Nil
+
+  property forgainst : Nil
+
+  property grainering : Nil
+
+  property irrevoluble : Nil
+
+  property kindredship : Nil
+
+  property pinguitudinous : Nil
+
+  property simpletonic : Nil
+
+  property singsong : Nil
+
+  property submergement : Nil
+
+  property supraoesophagal : Nil
+
+  property thrashel : Nil
+
+  property tyremesis : Nil
+
+  @[JSON::Field(key: "Yoruba")]
+  property yoruba : Nil
+end
+
+class PrefreshmanClass
+  include JSON::Serializable
+
+  property azorubine : Nil
+
+  property choroiditis : Nil
+
+  property coagulatory : Nil
+
+  property cyclorama : Nil
+
+  @[JSON::Field(key: "Dolphus")]
+  property dolphus : Nil
+
+  property duckhearted : Nil
+
+  @[JSON::Field(key: "Ficus")]
+  property ficus : Nil
+
+  @[JSON::Field(key: "Gemaric")]
+  property gemaric : Nil
+
+  property jugation : Nil
+
+  property myoliposis : Nil
+
+  property nonnomination : Nil
+
+  property palay : Nil
+
+  property pentactinal : Nil
+
+  @[JSON::Field(key: "Phaet")]
+  property phaet : Nil
+
+  property piquant : Nil
+
+  property registration : Nil
+
+  property remancipation : Nil
+
+  property scutatiform : Nil
+
+  property theodolite : Nil
+
+  property underward : Nil
+end
+
+alias JurorElement = JurorClass | Bool
+
+alias Kongoni = Array(Int32) | Hash(String, Int32)
+
+alias LadronismElement = Float64 | LadronismClass | String
+
+alias LandlubberlyElement = Int32 | LandlubberlyClass | Bool
+
+alias Listener = Int32 | Array(Nil)
+
+alias LupusElement = Int32 | LupusClass
+
+alias MonaziteElement = Float64 | MonaziteClass
+
+alias Monoliteral = Array(Nil) | Bool
+
+alias MonotheisticallyElement = MonotheisticallyClass | Array(Nil)
+
+alias Montage = Float64 | Array(Nil) | String
+
+alias Moralness = Float64 | Array(Nil)
+
+alias Mulishly = Float64 | Array(Int32)
+
+alias Myoscope = Int32 | Array(Nil) | Bool
+
+alias Neuromastic = Float64 | Array(Nil)
+
+alias Nonnervous = Int32 | Bool
+
+alias Nonvaluation = Float64 | Array(Nil) | Bool
+
+alias OccupationalistElement = Array(Nil) | OccupationalistClass
+
+alias OutrivalElement = Float64 | OutrivalClass
+
+alias Paleographically = Float64 | Hash(String, Int32?)
+
+alias Pamphletwise = Int32 | Hash(String, Int32) | String
+
+alias Pediatric = Float64 | Bool
+
+alias PiaculumElement = Float64 | PiaculumClass
+
+alias Piccadilly = Float64 | String
+
+alias Piffler = MonaziteClass | Array(Nil)
+
+alias Pithful = Int32 | Bool
+
+alias Placuntiti = Int32 | Hash(String, Int32)
+
+alias Plectopterous = Float64 | Hash(String, Int32)
+
+alias Poliorcetic = MonaziteClass | Bool
+
+alias Poormaster = Array(Int32) | Hash(String, Int32)
+
+alias PotwhiskyElement = Int32 | PotwhiskyClass
+
+alias Practicalizer = MonaziteClass | Array(Nil) | String
+
+alias PrefreshmanElement = Array(Nil) | PrefreshmanClass | String
+
+alias Prehensility = MonaziteClass | Array(Nil) | Bool
+
+alias Prevoidance = Int32 | Array(Int32) | MonaziteClass
+
+alias Protext = Array(Int32) | MonaziteClass | Bool
diff --git a/head/crystal/test/inputs/json/priority/combinations4.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/combinations4.json/default/TopLevel.cr
new file mode 100644
index 0000000..c180769
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/combinations4.json/default/TopLevel.cr
@@ -0,0 +1,964 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property protrusive : Array(Protrusive)
+
+  property pulpitism : Array(PulpitismElement)
+
+  property pyodermia : Array(PyodermiaElement)
+
+  property quebrachine : Array(QuebrachineElement?)
+
+  property querier : Array(Querier)
+
+  property rebarbative : Array(Rebarbative)
+
+  property reimagine : Array(Reimagine)
+
+  property ressaut : Ressaut
+
+  property retrocervical : Array(Retrocervical)
+
+  property revert : Array(Revert)
+
+  property rewrite : Array(RewriteElement)
+
+  property saccoderm : Array(Saccoderm?)
+
+  property santir : Array(SantirElement)
+
+  property saprophilous : Array(Saprophilous?)
+
+  property saxten : Array(SaxtenElement)
+
+  property scatty : Array(Scatty?)
+
+  property scoffer : Array(Scoffer?)
+
+  property scrampum : Array(Scrampum?)
+
+  property semantic : Float64
+
+  property serpentinic : Array(Serpentinic)
+
+  property shadowable : Array(Shadowable)
+
+  property sistering : Array(SisteringElement)
+
+  property staghunting : Array(Staghunting)
+
+  property stagmometer : Array(Stagmometer)
+
+  property stimulability : Array(Stimulability)
+
+  property strangleable : Array(Strangleable)
+
+  property strenuosity : Array(StrenuosityElement)
+
+  property tabaxir : Array(Tabaxir)
+
+  property talpiform : Array(Talpiform?)
+
+  property thwack : Array(Thwack)
+
+  property to : Array(Float64?)
+
+  property tortricine : Array(Tortricine)
+
+  property truantcy : Array(TruantcyElement)
+
+  property turgesce : Array(String)
+
+  property unbeginning : Array(Unbeginning)
+
+  property underdunged : Array(Float64)
+
+  property undesirability : Array(Undesirability)
+
+  property unerasing : Array(Unerasing)
+
+  property unguentarium : Array(Unguentarium?)
+
+  property unimpeachably : Array(UnimpeachablyElement)
+
+  property unmortgaged : Array(Unmortgaged?)
+
+  property unobstructed : Array(Unobstructed?)
+
+  property unreceptivity : Array(Unreceptivity)
+
+  property unsatisfactoriness : Array(Unsatisfactoriness)
+
+  property unsecurity : Array(Int32)
+
+  property unstressed : Array(UnstressedElement)
+
+  property untasked : Array(Untasked)
+
+  property unvarying : Array(Unvarying)
+
+  property vehemently : Array(Vehemently?)
+
+  property warriorship : Hash(String, Bool)
+
+  property whitepot : Array(Whitepot)
+
+  property wrothy : Array(WrothyElement)
+end
+
+class PulpitismClass
+  include JSON::Serializable
+
+  property abnet : Nil
+
+  property buckhorn : Nil
+
+  property calciform : Nil
+
+  property chelophore : Nil
+
+  property cogitation : Nil
+
+  property decreeable : Nil
+
+  property despicable : Nil
+
+  property isodiazo : Nil
+
+  property jadedly : Nil
+
+  property leptochlorite : Nil
+
+  property nursling : Nil
+
+  property palamedean : Nil
+
+  property photoheliograph : Nil
+
+  property pipewood : Nil
+
+  property roberd : Nil
+
+  property statable : Nil
+
+  property superassume : Nil
+
+  property syllabe : Nil
+
+  property toughhead : Nil
+
+  property underburn : Nil
+end
+
+class PyodermiaClass
+  include JSON::Serializable
+
+  property aphoristically : Nil
+
+  property apophyllous : Nil
+
+  property cognize : Nil
+
+  property dermonosology : Nil
+
+  @[JSON::Field(key: "Gyppo")]
+  property gyppo : Nil
+
+  property ither : Nil
+
+  property juglandaceous : Nil
+
+  property litho : Nil
+
+  property macropterous : Nil
+
+  property photographer : Nil
+
+  property romancing : Nil
+
+  property rumness : Nil
+
+  property somniloquist : Nil
+
+  property stressfully : Nil
+
+  property tactically : Nil
+
+  property tracheophony : Nil
+
+  property unappositely : Nil
+
+  property unclothedly : Nil
+
+  property unimplied : Nil
+
+  property unsyncopated : Nil
+end
+
+class QuebrachineClass
+  include JSON::Serializable
+
+  property catharticalness : Float64
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32
+
+  property disdiapason : String
+
+  property homocerc : Bool
+
+  property nonbookish : Nil
+end
+
+class Reimagine
+  include JSON::Serializable
+
+  property adducible : Nil
+
+  property anabolin : Nil
+
+  property brainy : Nil
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property chrysamine : Nil
+
+  property disdiapason : String?
+
+  property fluxweed : Nil
+
+  property glaucine : Nil
+
+  property grobianism : Nil
+
+  @[JSON::Field(key: "Hermo")]
+  property hermo : Nil
+
+  property hieroglyphist : Nil
+
+  property homocerc : Bool?
+
+  property icteroid : Nil
+
+  property immortal : Nil
+
+  property impetulant : Nil
+
+  property irrigate : Nil
+
+  property myxedema : Nil
+
+  property nonbookish : Nil
+
+  property onyx : Nil
+
+  property repasser : Nil
+
+  property septomarginal : Nil
+
+  property subdie : Nil
+
+  property tibiometatarsal : Nil
+
+  property waltzlike : Nil
+end
+
+class Ressaut
+  include JSON::Serializable
+
+  property apperceptive : String
+
+  property cuttoo : String
+
+  property douser : String
+
+  property drinkproof : String
+
+  property forementioned : String
+
+  @[JSON::Field(key: "Freesia")]
+  property freesia : String
+
+  @[JSON::Field(key: "Genevieve")]
+  property genevieve : String
+
+  property hyperdiabolical : String
+
+  property hypocone : String
+
+  property irreverentially : String
+
+  property jumart : String
+
+  @[JSON::Field(key: "Mimosaceae")]
+  property mimosaceae : String
+
+  property mollicrush : String
+
+  property nedder : String
+
+  property retinasphalt : String
+
+  property sough : String
+
+  property steading : String
+
+  @[JSON::Field(key: "Theopaschitism")]
+  property theopaschitism : String
+
+  property undurableness : String
+
+  property unmingleable : String
+end
+
+class RewriteClass
+  include JSON::Serializable
+
+  property accountancy : Nil
+
+  property cacotrophic : Nil
+
+  property contest : Nil
+
+  property couthily : Nil
+
+  property falculate : Nil
+
+  property foreseize : Nil
+
+  @[JSON::Field(key: "Hyades")]
+  property hyades : Nil
+
+  property lemnad : Nil
+
+  property monotheistically : Nil
+
+  property nonflying : Nil
+
+  @[JSON::Field(key: "Ptenoglossa")]
+  property ptenoglossa : Nil
+
+  property repatch : Nil
+
+  property rodman : Nil
+
+  property strung : Nil
+
+  property titmal : Nil
+
+  property twalpennyworth : Nil
+
+  property unblamable : Nil
+
+  property vertical : Nil
+
+  @[JSON::Field(key: "Whiggification")]
+  property whiggification : Nil
+
+  property yardman : Nil
+end
+
+class SantirClass
+  include JSON::Serializable
+
+  property admiredly : Nil
+
+  property demicaponier : Nil
+
+  property epitympanic : Nil
+
+  property investitor : Nil
+
+  property lupiform : Nil
+
+  property monoflagellate : Nil
+
+  property paleoethnic : Nil
+
+  property prediscountable : Nil
+
+  property rhetoricals : Nil
+
+  property roomth : Nil
+
+  property saccharose : Nil
+
+  property septonasal : Nil
+
+  property serpenticide : Nil
+
+  property setarious : Nil
+
+  property spaework : Nil
+
+  property stylite : Nil
+
+  @[JSON::Field(key: "Suessiones")]
+  property suessiones : Nil
+
+  property timelily : Nil
+
+  property unprofaned : Nil
+
+  property vorticular : Nil
+end
+
+class SaxtenClass
+  include JSON::Serializable
+
+  property algarrobilla : Nil
+
+  property bowgrace : Nil
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Centaurid")]
+  property centaurid : Nil
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property disdiapason : String?
+
+  property flix : Nil
+
+  property germanely : Nil
+
+  property homocerc : Bool?
+
+  property inhume : Nil
+
+  property lepidote : Nil
+
+  property megalochirous : Nil
+
+  property ninepenny : Nil
+
+  property nonbookish : Nil
+
+  property nondeist : Nil
+
+  property nymphaeaceous : Nil
+
+  property parietofrontal : Nil
+
+  property sancyite : Nil
+
+  property subjectivist : Nil
+
+  property tibiad : Nil
+
+  property transonic : Nil
+
+  property tripetalous : Nil
+
+  property trunchman : Nil
+
+  property urger : Nil
+
+  property withdrawnness : Nil
+end
+
+class Scatty
+  include JSON::Serializable
+
+  property aeriferous : Nil
+
+  property antical : Nil
+
+  property antighostism : Nil
+
+  property arcanum : Nil
+
+  property autotrophy : Nil
+
+  property baronial : Nil
+
+  property caffeine : Nil
+
+  property gorgoniacean : Nil
+
+  property heroical : Nil
+
+  property hydropical : Nil
+
+  property mechanology : Nil
+
+  property musicopoetic : Nil
+
+  property officiality : Nil
+
+  property oftentimes : Nil
+
+  property ophthalmotonometer : Nil
+
+  property reflectively : Nil
+
+  property springer : Nil
+
+  @[JSON::Field(key: "Tabasco")]
+  property tabasco : Nil
+
+  property teleianthous : Nil
+
+  property uncombated : Nil
+end
+
+class SisteringClass
+  include JSON::Serializable
+
+  property amphicarpic : Nil
+
+  @[JSON::Field(key: "Chianti")]
+  property chianti : Nil
+
+  property frigorific : Nil
+
+  @[JSON::Field(key: "Haplomi")]
+  property haplomi : Nil
+
+  property hyperkinesis : Nil
+
+  property laudable : Nil
+
+  property madwoman : Nil
+
+  property maimedly : Nil
+
+  @[JSON::Field(key: "Micropterygidae")]
+  property micropterygidae : Nil
+
+  property microrhabdus : Nil
+
+  property nondense : Nil
+
+  property phlebemphraxis : Nil
+
+  property redsear : Nil
+
+  property schismatical : Nil
+
+  property tartryl : Nil
+
+  property unabhorred : Nil
+
+  property undeliberateness : Nil
+
+  property unmixable : Nil
+
+  property untruckling : Nil
+
+  property vineal : Nil
+end
+
+class Staghunting
+  include JSON::Serializable
+
+  property calorimetric : Int32?
+
+  property canid : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property disdiapason : String?
+
+  property ditriglyphic : Int32?
+
+  property floriferousness : Int32?
+
+  property gamelike : Int32?
+
+  property grig : Int32?
+
+  property homocerc : Bool?
+
+  property interloan : Int32?
+
+  property lithotomy : Int32?
+
+  property loric : Int32?
+
+  property membranocoriaceous : Int32?
+
+  property membranogenic : Int32?
+
+  property nonbookish : Nil
+
+  property overtrump : Int32?
+
+  property scotino : Int32?
+
+  property seasonable : Int32?
+
+  property sephen : Int32?
+
+  property stigmarioid : Int32?
+
+  property tired : Int32?
+
+  property trifid : Int32?
+
+  property undefeatedly : Int32?
+
+  property ungirlish : Int32?
+end
+
+class StrenuosityClass
+  include JSON::Serializable
+
+  property bliss : Int32?
+
+  property buccate : Int32?
+
+  property bulletproof : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property crumblingness : Int32?
+
+  property disdiapason : String?
+
+  property engagedly : Int32?
+
+  property fightable : Int32?
+
+  property hoariness : Int32?
+
+  property homocerc : Bool?
+
+  property hypopodium : Int32?
+
+  property luxurist : Int32?
+
+  property mechanician : Int32?
+
+  property nonbookish : Nil
+
+  @[JSON::Field(key: "Onopordon")]
+  property onopordon : Int32?
+
+  property podgily : Int32?
+
+  property reformableness : Int32?
+
+  property scatterbrains : Int32?
+
+  property seminuria : Int32?
+
+  @[JSON::Field(key: "Sodomite")]
+  property sodomite : Int32?
+
+  property tramp : Int32?
+
+  property undueness : Int32?
+
+  property worthily : Int32?
+
+  @[JSON::Field(key: "Yankeeist")]
+  property yankeeist : Int32?
+end
+
+class TruantcyClass
+  include JSON::Serializable
+
+  property alfiona : Nil
+
+  property ascaridiasis : Nil
+
+  property bungey : Nil
+
+  property catharticalness : Float64?
+
+  property ceroxyle : Nil
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property chorology : Nil
+
+  property disdiapason : String?
+
+  property enmarble : Nil
+
+  @[JSON::Field(key: "Epeira")]
+  property epeira : Nil
+
+  @[JSON::Field(key: "Eurylaimi")]
+  property eurylaimi : Nil
+
+  property germination : Nil
+
+  property hallelujah : Nil
+
+  property homocerc : Bool?
+
+  property lev : Nil
+
+  property mouthing : Nil
+
+  property nonbookish : Nil
+
+  property philliloo : Nil
+
+  property planetal : Nil
+
+  property poney : Nil
+
+  property punctualist : Nil
+
+  property returnlessly : Nil
+
+  property skelder : Nil
+
+  property windwaywardly : Nil
+
+  @[JSON::Field(key: "Yuman")]
+  property yuman : Nil
+end
+
+class UnimpeachablyClass
+  include JSON::Serializable
+
+  property acerin : Int32?
+
+  @[JSON::Field(key: "Bobadil")]
+  property bobadil : Int32?
+
+  property catharticalness : Float64?
+
+  @[JSON::Field(key: "Chirotherium")]
+  property chirotherium : Int32?
+
+  property chlorophylligenous : Int32?
+
+  property conversational : Int32?
+
+  property demiowl : Int32?
+
+  property disdiapason : String?
+
+  property ectorhinal : Int32?
+
+  property gamblesomeness : Int32?
+
+  property homocerc : Bool?
+
+  property irrorate : Int32?
+
+  property kindergartening : Int32?
+
+  property lateritic : Int32?
+
+  property mespil : Int32?
+
+  property misconfiguration : Int32?
+
+  property nonbookish : Nil
+
+  property planometry : Int32?
+
+  @[JSON::Field(key: "Quiina")]
+  property quiina : Int32?
+
+  @[JSON::Field(key: "Robert")]
+  property robert : Int32?
+
+  property rot : Int32?
+
+  property subcinctorium : Int32?
+
+  property tussocker : Int32?
+
+  property ultraproud : Int32?
+
+  property unsuggestedness : Int32?
+end
+
+class UnstressedClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Alain")]
+  property alain : Nil
+
+  @[JSON::Field(key: "Amphirhina")]
+  property amphirhina : Nil
+
+  property antimachinery : Nil
+
+  property coldish : Nil
+
+  property crantara : Nil
+
+  property distinguishing : Nil
+
+  property elytroposis : Nil
+
+  property gentianwort : Nil
+
+  property heliosis : Nil
+
+  property instrumental : Nil
+
+  property introinflection : Nil
+
+  property kala : Nil
+
+  @[JSON::Field(key: "Lincolnian")]
+  property lincolnian : Nil
+
+  property metad : Nil
+
+  @[JSON::Field(key: "Sarcophilus")]
+  property sarcophilus : Nil
+
+  property swingingly : Nil
+
+  property unconformity : Nil
+
+  property undecreed : Nil
+
+  property venerable : Nil
+
+  property vowellessness : Nil
+end
+
+class WrothyClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Aeschynanthus")]
+  property aeschynanthus : Nil
+
+  property aquiferous : Nil
+
+  property cheapener : Nil
+
+  property enumeration : Nil
+
+  @[JSON::Field(key: "Ephesine")]
+  property ephesine : Nil
+
+  property escadrille : Nil
+
+  property estrous : Nil
+
+  property interestedly : Nil
+
+  property katakinetomer : Nil
+
+  property mortification : Nil
+
+  property morula : Nil
+
+  property orthosymmetrical : Nil
+
+  property overbark : Nil
+
+  property politist : Nil
+
+  property qualified : Nil
+
+  property sphenomalar : Nil
+
+  property throatful : Nil
+
+  property transhumance : Nil
+
+  property triandrian : Nil
+
+  property unbooked : Nil
+end
+
+alias Protrusive = Float64 | Array(Int32?)
+
+alias PulpitismElement = Float64 | Array(Int32) | PulpitismClass
+
+alias PyodermiaElement = Int32 | PyodermiaClass
+
+alias QuebrachineElement = Bool | QuebrachineClass
+
+alias Querier = Hash(String, Int32) | Bool
+
+alias Rebarbative = Float64 | Array(Int32) | Bool
+
+alias Retrocervical = Int32 | Array(Int32?)
+
+alias Revert = Bool | String
+
+alias RewriteElement = Float64 | Array(Nil) | RewriteClass
+
+alias Saccoderm = Array(Int32) | String
+
+alias SantirElement = Float64 | SantirClass
+
+alias Saprophilous = Hash(String, Int32) | String
+
+alias SaxtenElement = String | SaxtenClass
+
+alias Scoffer = Hash(String, Int32) | Array(Nil)
+
+alias Scrampum = Array(Int32) | Bool
+
+alias Serpentinic = Float64 | Array(Int32)
+
+alias Shadowable = Bool | Array(Int32?)
+
+alias SisteringElement = Int32 | Array(Nil) | SisteringClass
+
+alias Stagmometer = String | Array(Int32?)
+
+alias Stimulability = Int32 | Hash(String, Int32) | Bool
+
+alias Strangleable = Float64 | Array(Nil)
+
+alias StrenuosityElement = Array(Nil) | StrenuosityClass
+
+alias Tabaxir = Float64 | Bool
+
+alias Talpiform = Float64 | QuebrachineClass
+
+alias Thwack = Float64 | Bool | QuebrachineClass
+
+alias Tortricine = QuebrachineClass | Array(Int32?)
+
+alias TruantcyElement = Bool | TruantcyClass
+
+alias Unbeginning = Hash(String, Int32) | Array(Nil) | String
+
+alias Undesirability = Array(Int32) | Hash(String, Int32) | String
+
+alias Unerasing = Int32 | Hash(String, Int32) | Array(Nil)
+
+alias Unguentarium = Int32 | Array(Nil)
+
+alias UnimpeachablyElement = Bool | UnimpeachablyClass
+
+alias Unmortgaged = Float64 | Hash(String, Int32)
+
+alias Unobstructed = Int32 | QuebrachineClass
+
+alias Unreceptivity = Int32 | Array(Nil) | String
+
+alias Unsatisfactoriness = Int32 | Array(Int32) | Bool
+
+alias UnstressedElement = Bool | String | UnstressedClass
+
+alias Untasked = Float64 | Hash(String, Int32) | Array(Nil)
+
+alias Unvarying = Float64 | Hash(String, Int32) | Bool
+
+alias Vehemently = Array(Nil) | Bool
+
+alias Whitepot = Float64 | QuebrachineClass
+
+alias WrothyElement = Array(Nil) | WrothyClass
diff --git a/head/crystal/test/inputs/json/priority/combined-enum.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/combined-enum.json/default/TopLevel.cr
new file mode 100644
index 0000000..9443672
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/combined-enum.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property bar : Array(Bar)
+
+  property foo : Array(Bar)
+end
+
+class Bar
+  include JSON::Serializable
+
+  property x : String
+end
diff --git a/head/crystal/test/inputs/json/priority/direct-recursive.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/direct-recursive.json/default/TopLevel.cr
new file mode 100644
index 0000000..b7c5109
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/direct-recursive.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property also : TopLevel?
+
+  property bar : Bool
+
+  property foo : Int32
+
+  property moo : Float64
+
+  property quux : String
+end
diff --git a/head/crystal/test/inputs/json/priority/empty-enum.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/empty-enum.json/default/TopLevel.cr
new file mode 100644
index 0000000..2ac09b8
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/empty-enum.json/default/TopLevel.cr
@@ -0,0 +1,13 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Array(Foo)
+end
+
+class Foo
+  include JSON::Serializable
+
+  property bar : String?
+end
diff --git a/head/crystal/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.cr
new file mode 100644
index 0000000..a22a4fd
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property key : String
+end
diff --git a/head/crystal/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.cr
new file mode 100644
index 0000000..8607039
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Array(Int32)
diff --git a/head/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr
new file mode 100644
index 0000000..60dba38
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/keywords.json/default/TopLevel.cr
@@ -0,0 +1,2402 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property dummy : Int32
+
+  property obj1 : Obj1
+
+  property obj2 : Obj2
+
+  property obj3 : Obj3
+
+  property obj4 : Obj4
+
+  property obj5 : Obj5
+end
+
+class Obj1
+  include JSON::Serializable
+
+  property alignas : Alignas
+
+  property alignof : Alignof
+
+  property and : And
+
+  property and_eq : AndEq
+
+  @[JSON::Field(key: "Any")]
+  property any : AnyClass
+
+  property array : ArrayClass
+
+  property assert : Assert
+
+  property associatedtype : Associatedtype
+
+  property associativity : Associativity
+
+  property async : Async
+
+  property atomic : AtomicClass
+
+  property atomic_cancel : AtomicCancel
+
+  property atomic_commit : AtomicCommit
+
+  property atomic_noexcept : AtomicNoexcept
+
+  property auto : Auto
+
+  property await : Await
+
+  property base : Base
+
+  property bitand : Bitand
+
+  property bitor : Bitor
+
+  @[JSON::Field(key: "BOOL")]
+  property bool : BoolClass
+
+  property boolean : Boolean
+
+  property bycopy : Bycopy
+
+  property byref : Byref
+
+  property byte : Byte
+
+  property catch : Catch
+
+  property chan : Chan
+
+  property char : CharClass
+
+  property char16_t : Char16T
+
+  property char32_t : Char32T
+
+  property checked : Checked
+
+  property clone : Clone
+
+  property co_await : CoAwait
+
+  property co_return : CoReturn
+
+  property co_yield : CoYield
+
+  property compl : Compl
+
+  @[JSON::Field(key: "_Complex")]
+  property complex : Complex
+
+  property concept : Concept
+
+  property console : Console
+
+  property const : Const
+
+  property const_cast : ConstCast
+
+  property constexpr : Constexpr
+
+  property constructor : Constructor
+
+  property continue : Continue
+
+  property convenience : Convenience
+
+  property convert : Convert
+
+  property converter : Converter
+
+  property date : Date
+
+  property date_parse_handling : DateParseHandling
+
+  property debugger : Debugger
+
+  property decimal : Decimal
+
+  property declare : Declare
+
+  property decltype : Decltype
+
+  property decode_string : DecodeString
+
+  property dummy : Int32
+
+  @[JSON::Field(key: "_")]
+  property empty : Empty
+
+  @[JSON::Field(key: "_Imaginery")]
+  property imaginery : Imaginery
+
+  @[JSON::Field(key: "abstract")]
+  property obj1_abstract : Abstract
+
+  @[JSON::Field(key: "any")]
+  property obj1_any : Obj1Any
+
+  @[JSON::Field(key: "as")]
+  property obj1_as : As
+
+  @[JSON::Field(key: "asm")]
+  property obj1_asm : Asm
+
+  @[JSON::Field(key: "_Bool")]
+  property obj1_bool : Obj1Bool
+
+  @[JSON::Field(key: "break")]
+  property obj1_break : Break
+
+  @[JSON::Field(key: "case")]
+  property obj1_case : Case
+
+  @[JSON::Field(key: "Class")]
+  property obj1_class : ClassClass
+
+  @[JSON::Field(key: "bool")]
+  property purple_bool : Obj1BoolClass
+
+  @[JSON::Field(key: "class")]
+  property purple_class : Obj1Class
+end
+
+class Alignas
+  include JSON::Serializable
+
+  property alignas : Int32
+end
+
+class Alignof
+  include JSON::Serializable
+
+  property alignof : Int32
+end
+
+class And
+  include JSON::Serializable
+
+  property and : Int32
+end
+
+class AndEq
+  include JSON::Serializable
+
+  property and_eq : Int32
+end
+
+class AnyClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Any")]
+  property any : Int32
+end
+
+class ArrayClass
+  include JSON::Serializable
+
+  property array : Int32
+end
+
+class Assert
+  include JSON::Serializable
+
+  property assert : Int32
+end
+
+class Associatedtype
+  include JSON::Serializable
+
+  property associatedtype : Int32
+end
+
+class Associativity
+  include JSON::Serializable
+
+  property associativity : Int32
+end
+
+class Async
+  include JSON::Serializable
+
+  property async : Int32
+end
+
+class AtomicClass
+  include JSON::Serializable
+
+  property atomic : Int32
+end
+
+class AtomicCancel
+  include JSON::Serializable
+
+  property atomic_cancel : Int32
+end
+
+class AtomicCommit
+  include JSON::Serializable
+
+  property atomic_commit : Int32
+end
+
+class AtomicNoexcept
+  include JSON::Serializable
+
+  property atomic_noexcept : Int32
+end
+
+class Auto
+  include JSON::Serializable
+
+  property auto : Int32
+end
+
+class Await
+  include JSON::Serializable
+
+  property await : Int32
+end
+
+class Base
+  include JSON::Serializable
+
+  property base : Int32
+end
+
+class Bitand
+  include JSON::Serializable
+
+  property bitand : Int32
+end
+
+class Bitor
+  include JSON::Serializable
+
+  property bitor : Int32
+end
+
+class BoolClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "BOOL")]
+  property bool : Int32
+end
+
+class Boolean
+  include JSON::Serializable
+
+  property boolean : Int32
+end
+
+class Bycopy
+  include JSON::Serializable
+
+  property bycopy : Int32
+end
+
+class Byref
+  include JSON::Serializable
+
+  property byref : Int32
+end
+
+class Byte
+  include JSON::Serializable
+
+  property byte : Int32
+end
+
+class Catch
+  include JSON::Serializable
+
+  property catch : Int32
+end
+
+class Chan
+  include JSON::Serializable
+
+  property chan : Int32
+end
+
+class CharClass
+  include JSON::Serializable
+
+  property char : Int32
+end
+
+class Char16T
+  include JSON::Serializable
+
+  property char16_t : Int32
+end
+
+class Char32T
+  include JSON::Serializable
+
+  property char32_t : Int32
+end
+
+class Checked
+  include JSON::Serializable
+
+  property checked : Int32
+end
+
+class Clone
+  include JSON::Serializable
+
+  property clone : Int32
+end
+
+class CoAwait
+  include JSON::Serializable
+
+  property co_await : Int32
+end
+
+class CoReturn
+  include JSON::Serializable
+
+  property co_return : Int32
+end
+
+class CoYield
+  include JSON::Serializable
+
+  property co_yield : Int32
+end
+
+class Compl
+  include JSON::Serializable
+
+  property compl : Int32
+end
+
+class Complex
+  include JSON::Serializable
+
+  @[JSON::Field(key: "_Complex")]
+  property complex : Int32
+end
+
+class Concept
+  include JSON::Serializable
+
+  property concept : Int32
+end
+
+class Console
+  include JSON::Serializable
+
+  property console : Int32
+end
+
+class Const
+  include JSON::Serializable
+
+  property const : Int32
+end
+
+class ConstCast
+  include JSON::Serializable
+
+  property const_cast : Int32
+end
+
+class Constexpr
+  include JSON::Serializable
+
+  property constexpr : Int32
+end
+
+class Constructor
+  include JSON::Serializable
+
+  property constructor : Int32
+end
+
+class Continue
+  include JSON::Serializable
+
+  property continue : Int32
+end
+
+class Convenience
+  include JSON::Serializable
+
+  property convenience : Int32
+end
+
+class Convert
+  include JSON::Serializable
+
+  property convert : Int32
+end
+
+class Converter
+  include JSON::Serializable
+
+  property converter : Int32
+end
+
+class Date
+  include JSON::Serializable
+
+  property date : Int32
+end
+
+class DateParseHandling
+  include JSON::Serializable
+
+  property date_parse_handling : Int32
+end
+
+class Debugger
+  include JSON::Serializable
+
+  property debugger : Int32
+end
+
+class Decimal
+  include JSON::Serializable
+
+  property decimal : Int32
+end
+
+class Declare
+  include JSON::Serializable
+
+  property declare : Int32
+end
+
+class Decltype
+  include JSON::Serializable
+
+  property decltype : Int32
+end
+
+class DecodeString
+  include JSON::Serializable
+
+  property decode_string : Int32
+end
+
+class Empty
+  include JSON::Serializable
+
+  @[JSON::Field(key: "_")]
+  property empty : Int32
+end
+
+class Imaginery
+  include JSON::Serializable
+
+  @[JSON::Field(key: "_Imaginery")]
+  property imaginery : Int32
+end
+
+class Abstract
+  include JSON::Serializable
+
+  @[JSON::Field(key: "abstract")]
+  property abstract_abstract : Int32
+end
+
+class Obj1Any
+  include JSON::Serializable
+
+  property any : Int32
+end
+
+class As
+  include JSON::Serializable
+
+  @[JSON::Field(key: "as")]
+  property as_as : Int32
+end
+
+class Asm
+  include JSON::Serializable
+
+  @[JSON::Field(key: "asm")]
+  property asm_asm : Int32
+end
+
+class Obj1Bool
+  include JSON::Serializable
+
+  @[JSON::Field(key: "_Bool")]
+  property bool : Int32
+end
+
+class Break
+  include JSON::Serializable
+
+  @[JSON::Field(key: "break")]
+  property break_break : Int32
+end
+
+class Case
+  include JSON::Serializable
+
+  @[JSON::Field(key: "case")]
+  property case_case : Int32
+end
+
+class ClassClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Class")]
+  property class_class : Int32
+end
+
+class Obj1BoolClass
+  include JSON::Serializable
+
+  property bool : Int32
+end
+
+class Obj1Class
+  include JSON::Serializable
+
+  @[JSON::Field(key: "class")]
+  property class_class : Int32
+end
+
+class Obj2
+  include JSON::Serializable
+
+  property default : Default
+
+  property defer : Defer
+
+  property deinit : Deinit
+
+  property del : Del
+
+  property delegate : Delegate
+
+  property delete : Delete
+
+  property dict : Dict
+
+  property dictionary : Dictionary
+
+  @[JSON::Field(key: "didSet")]
+  property did_set : DidSet
+
+  property double : Double
+
+  property dummy : Int32
+
+  property dynamic : Dynamic
+
+  property dynamic_cast : DynamicCast
+
+  property elif : Elif
+
+  property encode_quick_type : EncodeQuickType
+
+  @[JSON::Field(key: "equalityContract")]
+  property equality_contract : EqualityContract
+
+  property event : EventClass
+
+  property except : Except
+
+  property exception : ExceptionClass
+
+  property explicit : Explicit
+
+  property export : Export
+
+  property exposing : Exposing
+
+  property extends : Extends
+
+  property extension : Extension
+
+  property extern : ExternClass
+
+  property fallthrough : Fallthrough
+
+  property fileprivate : Fileprivate
+
+  property final : Final
+
+  property finally : Finally
+
+  property fixed : Fixed
+
+  property float : FloatClass
+
+  property foreach : Foreach
+
+  property friend : Friend
+
+  property from : From
+
+  property from_json : FromJson
+
+  property func : Func
+
+  property function : Function
+
+  property get : Get
+
+  property global : Global
+
+  property go : Go
+
+  property goto : Goto
+
+  property guard : Guard
+
+  @[JSON::Field(key: "hasOwnProperty")]
+  property has_own_property : HasOwnProperty
+
+  property id : Id
+
+  @[JSON::Field(key: "IMP")]
+  property imp : Imp
+
+  property implements : Implements
+
+  property implicit : Implicit
+
+  property import : Import
+
+  property indirect : Indirect
+
+  property infix : Infix
+
+  property init : Init
+
+  property inline : Inline
+
+  property inout : Inout
+
+  property instanceof : Instanceof
+
+  property int : IntClass
+
+  property interface : Interface
+
+  property internal : Internal
+
+  @[JSON::Field(key: "def")]
+  property obj2_def : Def
+
+  @[JSON::Field(key: "do")]
+  property obj2_do : Do
+
+  @[JSON::Field(key: "else")]
+  property obj2_else : Else
+
+  @[JSON::Field(key: "enum")]
+  property obj2_enum : EnumClass
+
+  @[JSON::Field(key: "False")]
+  property obj2_false : False
+
+  @[JSON::Field(key: "for")]
+  property obj2_for : For
+
+  @[JSON::Field(key: "if")]
+  property obj2_if : If
+
+  @[JSON::Field(key: "in")]
+  property obj2_in : In
+
+  @[JSON::Field(key: "false")]
+  property purple_false : FalseClass
+end
+
+class Default
+  include JSON::Serializable
+
+  property default : Int32
+end
+
+class Defer
+  include JSON::Serializable
+
+  property defer : Int32
+end
+
+class Deinit
+  include JSON::Serializable
+
+  property deinit : Int32
+end
+
+class Del
+  include JSON::Serializable
+
+  property del : Int32
+end
+
+class Delegate
+  include JSON::Serializable
+
+  property delegate : Int32
+end
+
+class Delete
+  include JSON::Serializable
+
+  property delete : Int32
+end
+
+class Dict
+  include JSON::Serializable
+
+  property dict : Int32
+end
+
+class Dictionary
+  include JSON::Serializable
+
+  property dictionary : Int32
+end
+
+class DidSet
+  include JSON::Serializable
+
+  @[JSON::Field(key: "didSet")]
+  property did_set : Int32
+end
+
+class Double
+  include JSON::Serializable
+
+  property double : Int32
+end
+
+class Dynamic
+  include JSON::Serializable
+
+  property dynamic : Int32
+end
+
+class DynamicCast
+  include JSON::Serializable
+
+  property dynamic_cast : Int32
+end
+
+class Elif
+  include JSON::Serializable
+
+  property elif : Int32
+end
+
+class EncodeQuickType
+  include JSON::Serializable
+
+  property encode_quick_type : Int32
+end
+
+class EqualityContract
+  include JSON::Serializable
+
+  @[JSON::Field(key: "equalityContract")]
+  property equality_contract : Int32
+end
+
+class EventClass
+  include JSON::Serializable
+
+  property event : Int32
+end
+
+class Except
+  include JSON::Serializable
+
+  property except : Int32
+end
+
+class ExceptionClass
+  include JSON::Serializable
+
+  property exception : Int32
+end
+
+class Explicit
+  include JSON::Serializable
+
+  property explicit : Int32
+end
+
+class Export
+  include JSON::Serializable
+
+  property export : Int32
+end
+
+class Exposing
+  include JSON::Serializable
+
+  property exposing : Int32
+end
+
+class Extends
+  include JSON::Serializable
+
+  property extends : Int32
+end
+
+class Extension
+  include JSON::Serializable
+
+  property extension : Int32
+end
+
+class ExternClass
+  include JSON::Serializable
+
+  property extern : Int32
+end
+
+class Fallthrough
+  include JSON::Serializable
+
+  property fallthrough : Int32
+end
+
+class Fileprivate
+  include JSON::Serializable
+
+  property fileprivate : Int32
+end
+
+class Final
+  include JSON::Serializable
+
+  property final : Int32
+end
+
+class Finally
+  include JSON::Serializable
+
+  property finally : Int32
+end
+
+class Fixed
+  include JSON::Serializable
+
+  property fixed : Int32
+end
+
+class FloatClass
+  include JSON::Serializable
+
+  property float : Int32
+end
+
+class Foreach
+  include JSON::Serializable
+
+  property foreach : Int32
+end
+
+class Friend
+  include JSON::Serializable
+
+  property friend : Int32
+end
+
+class From
+  include JSON::Serializable
+
+  property from : Int32
+end
+
+class FromJson
+  include JSON::Serializable
+
+  property from_json : Int32
+end
+
+class Func
+  include JSON::Serializable
+
+  property func : Int32
+end
+
+class Function
+  include JSON::Serializable
+
+  property function : Int32
+end
+
+class Get
+  include JSON::Serializable
+
+  property get : Int32
+end
+
+class Global
+  include JSON::Serializable
+
+  property global : Int32
+end
+
+class Go
+  include JSON::Serializable
+
+  property go : Int32
+end
+
+class Goto
+  include JSON::Serializable
+
+  property goto : Int32
+end
+
+class Guard
+  include JSON::Serializable
+
+  property guard : Int32
+end
+
+class HasOwnProperty
+  include JSON::Serializable
+
+  @[JSON::Field(key: "hasOwnProperty")]
+  property has_own_property : Int32
+end
+
+class Id
+  include JSON::Serializable
+
+  property id : Int32
+end
+
+class Imp
+  include JSON::Serializable
+
+  @[JSON::Field(key: "IMP")]
+  property imp : Int32
+end
+
+class Implements
+  include JSON::Serializable
+
+  property implements : Int32
+end
+
+class Implicit
+  include JSON::Serializable
+
+  property implicit : Int32
+end
+
+class Import
+  include JSON::Serializable
+
+  property import : Int32
+end
+
+class Indirect
+  include JSON::Serializable
+
+  property indirect : Int32
+end
+
+class Infix
+  include JSON::Serializable
+
+  property infix : Int32
+end
+
+class Init
+  include JSON::Serializable
+
+  property init : Int32
+end
+
+class Inline
+  include JSON::Serializable
+
+  property inline : Int32
+end
+
+class Inout
+  include JSON::Serializable
+
+  property inout : Int32
+end
+
+class Instanceof
+  include JSON::Serializable
+
+  property instanceof : Int32
+end
+
+class IntClass
+  include JSON::Serializable
+
+  property int : Int32
+end
+
+class Interface
+  include JSON::Serializable
+
+  property interface : Int32
+end
+
+class Internal
+  include JSON::Serializable
+
+  property internal : Int32
+end
+
+class Def
+  include JSON::Serializable
+
+  @[JSON::Field(key: "def")]
+  property def_def : Int32
+end
+
+class Do
+  include JSON::Serializable
+
+  @[JSON::Field(key: "do")]
+  property do_do : Int32
+end
+
+class Else
+  include JSON::Serializable
+
+  @[JSON::Field(key: "else")]
+  property else_else : Int32
+end
+
+class EnumClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "enum")]
+  property enum_enum : Int32
+end
+
+class False
+  include JSON::Serializable
+
+  @[JSON::Field(key: "False")]
+  property false_false : Int32
+end
+
+class For
+  include JSON::Serializable
+
+  @[JSON::Field(key: "for")]
+  property for_for : Int32
+end
+
+class If
+  include JSON::Serializable
+
+  @[JSON::Field(key: "if")]
+  property if_if : Int32
+end
+
+class In
+  include JSON::Serializable
+
+  @[JSON::Field(key: "in")]
+  property in_in : Int32
+end
+
+class FalseClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "false")]
+  property false_false : Int32
+end
+
+class Obj3
+  include JSON::Serializable
+
+  property dummy : Int32
+
+  property is : Is
+
+  property iterable : IterableClass
+
+  property jdec : Jdec
+
+  property jenc : Jenc
+
+  property jpipe : Jpipe
+
+  property json : Json
+
+  property json_converter : JsonConverter
+
+  property json_serializer : JsonSerializer
+
+  property json_token : JsonToken
+
+  property json_writer : JsonWriter
+
+  property lambda : Lambda
+
+  property lazy : Lazy
+
+  property left : Left
+
+  property let : Let
+
+  property list : List
+
+  property lock : Lock
+
+  property long : Long
+
+  property map : Map
+
+  property metadata_property_handling : MetadataPropertyHandling
+
+  property mutable : Mutable
+
+  property mutating : Mutating
+
+  property namespace : Namespace
+
+  property native : Native
+
+  property new : New
+
+  property newtonsoft : Newtonsoft
+
+  @[JSON::Field(key: "NO")]
+  property no : No
+
+  property noexcept : Noexcept
+
+  property nonatomic : Nonatomic
+
+  @[JSON::Field(key: "None")]
+  property none : None
+
+  property nonlocal : Nonlocal
+
+  property nonmutating : Nonmutating
+
+  property not : Not
+
+  property not_eq : NotEq
+
+  @[JSON::Field(key: "NSString")]
+  property ns_string : NsString
+
+  @[JSON::Field(key: "NULL")]
+  property null : Null
+
+  property nullptr : Nullptr
+
+  property number : NumberClass
+
+  @[JSON::Field(key: "module")]
+  property obj3_module : Module
+
+  @[JSON::Field(key: "nil")]
+  property obj3_nil : NilClass
+
+  @[JSON::Field(key: "none")]
+  property obj3_none : NoneClass
+
+  @[JSON::Field(key: "null")]
+  property obj3_null : NullClass
+
+  @[JSON::Field(key: "of")]
+  property obj3_of : Of
+
+  @[JSON::Field(key: "out")]
+  property obj3_out : Out
+
+  @[JSON::Field(key: "private")]
+  property obj3_private : Private
+
+  @[JSON::Field(key: "protected")]
+  property obj3_protected : Protected
+
+  @[JSON::Field(key: "protocol")]
+  property obj3_protocol : ProtocolClass
+
+  property object : ObjectClass
+
+  property oneway : Oneway
+
+  property open : Open
+
+  property operator : Operator
+
+  property optional : Optional
+
+  property or : Or
+
+  property or_eq : OrEq
+
+  property override : Override
+
+  property package : Package
+
+  property params : Params
+
+  property pass : Pass
+
+  property port : Port
+
+  property postfix : Postfix
+
+  property precedence : Precedence
+
+  property prefix : Prefix
+
+  property print : Print
+
+  @[JSON::Field(key: "printMembers")]
+  property print_members : PrintMembers
+
+  property printf : Printf
+
+  @[JSON::Field(key: "Protocol")]
+  property protocol : Protocol
+end
+
+class Is
+  include JSON::Serializable
+
+  property is : Int32
+end
+
+class IterableClass
+  include JSON::Serializable
+
+  property iterable : Int32
+end
+
+class Jdec
+  include JSON::Serializable
+
+  property jdec : Int32
+end
+
+class Jenc
+  include JSON::Serializable
+
+  property jenc : Int32
+end
+
+class Jpipe
+  include JSON::Serializable
+
+  property jpipe : Int32
+end
+
+class Json
+  include JSON::Serializable
+
+  property json : Int32
+end
+
+class JsonConverter
+  include JSON::Serializable
+
+  property json_converter : Int32
+end
+
+class JsonSerializer
+  include JSON::Serializable
+
+  property json_serializer : Int32
+end
+
+class JsonToken
+  include JSON::Serializable
+
+  property json_token : Int32
+end
+
+class JsonWriter
+  include JSON::Serializable
+
+  property json_writer : Int32
+end
+
+class Lambda
+  include JSON::Serializable
+
+  property lambda : Int32
+end
+
+class Lazy
+  include JSON::Serializable
+
+  property lazy : Int32
+end
+
+class Left
+  include JSON::Serializable
+
+  property left : Int32
+end
+
+class Let
+  include JSON::Serializable
+
+  property let : Int32
+end
+
+class List
+  include JSON::Serializable
+
+  property list : Int32
+end
+
+class Lock
+  include JSON::Serializable
+
+  property lock : Int32
+end
+
+class Long
+  include JSON::Serializable
+
+  property long : Int32
+end
+
+class Map
+  include JSON::Serializable
+
+  property map : Int32
+end
+
+class MetadataPropertyHandling
+  include JSON::Serializable
+
+  property metadata_property_handling : Int32
+end
+
+class Mutable
+  include JSON::Serializable
+
+  property mutable : Int32
+end
+
+class Mutating
+  include JSON::Serializable
+
+  property mutating : Int32
+end
+
+class Namespace
+  include JSON::Serializable
+
+  property namespace : Int32
+end
+
+class Native
+  include JSON::Serializable
+
+  property native : Int32
+end
+
+class New
+  include JSON::Serializable
+
+  property new : Int32
+end
+
+class Newtonsoft
+  include JSON::Serializable
+
+  property newtonsoft : Int32
+end
+
+class No
+  include JSON::Serializable
+
+  @[JSON::Field(key: "NO")]
+  property no : Int32
+end
+
+class Noexcept
+  include JSON::Serializable
+
+  property noexcept : Int32
+end
+
+class Nonatomic
+  include JSON::Serializable
+
+  property nonatomic : Int32
+end
+
+class None
+  include JSON::Serializable
+
+  @[JSON::Field(key: "None")]
+  property none : Int32
+end
+
+class Nonlocal
+  include JSON::Serializable
+
+  property nonlocal : Int32
+end
+
+class Nonmutating
+  include JSON::Serializable
+
+  property nonmutating : Int32
+end
+
+class Not
+  include JSON::Serializable
+
+  property not : Int32
+end
+
+class NotEq
+  include JSON::Serializable
+
+  property not_eq : Int32
+end
+
+class NsString
+  include JSON::Serializable
+
+  @[JSON::Field(key: "NSString")]
+  property ns_string : Int32
+end
+
+class Null
+  include JSON::Serializable
+
+  @[JSON::Field(key: "NULL")]
+  property null : Int32
+end
+
+class Nullptr
+  include JSON::Serializable
+
+  property nullptr : Int32
+end
+
+class NumberClass
+  include JSON::Serializable
+
+  property number : Int32
+end
+
+class Module
+  include JSON::Serializable
+
+  @[JSON::Field(key: "module")]
+  property module_module : Int32
+end
+
+class NilClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "nil")]
+  property nil_nil : Int32
+end
+
+class NoneClass
+  include JSON::Serializable
+
+  property none : Int32
+end
+
+class NullClass
+  include JSON::Serializable
+
+  property null : Int32
+end
+
+class Of
+  include JSON::Serializable
+
+  @[JSON::Field(key: "of")]
+  property of_of : Int32
+end
+
+class Out
+  include JSON::Serializable
+
+  @[JSON::Field(key: "out")]
+  property out_out : Int32
+end
+
+class Private
+  include JSON::Serializable
+
+  @[JSON::Field(key: "private")]
+  property private_private : Int32
+end
+
+class Protected
+  include JSON::Serializable
+
+  @[JSON::Field(key: "protected")]
+  property protected_protected : Int32
+end
+
+class ProtocolClass
+  include JSON::Serializable
+
+  property protocol : Int32
+end
+
+class ObjectClass
+  include JSON::Serializable
+
+  property object : Int32
+end
+
+class Oneway
+  include JSON::Serializable
+
+  property oneway : Int32
+end
+
+class Open
+  include JSON::Serializable
+
+  property open : Int32
+end
+
+class Operator
+  include JSON::Serializable
+
+  property operator : Int32
+end
+
+class Optional
+  include JSON::Serializable
+
+  property optional : Int32
+end
+
+class Or
+  include JSON::Serializable
+
+  property or : Int32
+end
+
+class OrEq
+  include JSON::Serializable
+
+  property or_eq : Int32
+end
+
+class Override
+  include JSON::Serializable
+
+  property override : Int32
+end
+
+class Package
+  include JSON::Serializable
+
+  property package : Int32
+end
+
+class Params
+  include JSON::Serializable
+
+  property params : Int32
+end
+
+class Pass
+  include JSON::Serializable
+
+  property pass : Int32
+end
+
+class Port
+  include JSON::Serializable
+
+  property port : Int32
+end
+
+class Postfix
+  include JSON::Serializable
+
+  property postfix : Int32
+end
+
+class Precedence
+  include JSON::Serializable
+
+  property precedence : Int32
+end
+
+class Prefix
+  include JSON::Serializable
+
+  property prefix : Int32
+end
+
+class Print
+  include JSON::Serializable
+
+  property print : Int32
+end
+
+class PrintMembers
+  include JSON::Serializable
+
+  @[JSON::Field(key: "printMembers")]
+  property print_members : Int32
+end
+
+class Printf
+  include JSON::Serializable
+
+  property printf : Int32
+end
+
+class Protocol
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Protocol")]
+  property protocol : Int32
+end
+
+class Obj4
+  include JSON::Serializable
+
+  property dummy : Int32
+
+  @[JSON::Field(key: "require")]
+  property obj4_require : Require
+
+  @[JSON::Field(key: "return")]
+  property obj4_return : Return
+
+  @[JSON::Field(key: "select")]
+  property obj4_select : Select
+
+  @[JSON::Field(key: "Self")]
+  property obj4_self : Self
+
+  @[JSON::Field(key: "sizeof")]
+  property obj4_sizeof : Sizeof
+
+  @[JSON::Field(key: "struct")]
+  property obj4_struct : StructClass
+
+  @[JSON::Field(key: "super")]
+  property obj4_super : Super
+
+  @[JSON::Field(key: "then")]
+  property obj4_then : Then
+
+  @[JSON::Field(key: "True")]
+  property obj4_true : True
+
+  @[JSON::Field(key: "Type")]
+  property obj4_type : Type
+
+  @[JSON::Field(key: "typeof")]
+  property obj4_typeof : Typeof
+
+  property public : Public
+
+  @[JSON::Field(key: "self")]
+  property purple_self : SelfClass
+
+  @[JSON::Field(key: "true")]
+  property purple_true : TrueClass
+
+  @[JSON::Field(key: "type")]
+  property purple_type : TypeClass
+
+  property quicktype : Quicktype
+
+  property raise : Raise
+
+  property range : RangeClass
+
+  property readonly : Readonly
+
+  property ref : Ref
+
+  property register : Register
+
+  property reinterpret_cast : ReinterpretCast
+
+  property repeat : Repeat
+
+  property required : Required
+
+  property requires : Requires
+
+  property restrict : Restrict
+
+  property retain : Retain
+
+  property rethrows : Rethrows
+
+  property right : Right
+
+  property sbyte : Sbyte
+
+  property sealed : Sealed
+
+  @[JSON::Field(key: "SEL")]
+  property sel : Sel
+
+  property serialize : Serialize
+
+  property set : SetClass
+
+  property short : Short
+
+  property signed : Signed
+
+  property stackalloc : Stackalloc
+
+  property static : Static
+
+  property static_assert : StaticAssert
+
+  property static_cast : StaticCast
+
+  property strictfp : Strictfp
+
+  property string : StringClass
+
+  property subscript : Subscript
+
+  property switch : Switch
+
+  property symbol : SymbolClass
+
+  property synchronized : Synchronized
+
+  property system : SystemClass
+
+  property template : Template
+
+  property this : This
+
+  property thread_local : ThreadLocalClass
+
+  property throw : Throw
+
+  property throws : Throws
+
+  property to_json : ToJson
+
+  property top_level : TopLevelClass
+
+  property transient : Transient
+
+  property try : Try
+
+  property typealias : Typealias
+
+  property typedef : Typedef
+
+  property typeid : Typeid
+
+  property typename : Typename
+
+  property uint : Uint
+
+  property ulong : Ulong
+
+  property unchecked : Unchecked
+
+  property undefined : Undefined
+end
+
+class Require
+  include JSON::Serializable
+
+  @[JSON::Field(key: "require")]
+  property require_require : Int32
+end
+
+class Return
+  include JSON::Serializable
+
+  @[JSON::Field(key: "return")]
+  property return_return : Int32
+end
+
+class Select
+  include JSON::Serializable
+
+  @[JSON::Field(key: "select")]
+  property select_select : Int32
+end
+
+class Self
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Self")]
+  property self_self : Int32
+end
+
+class Sizeof
+  include JSON::Serializable
+
+  @[JSON::Field(key: "sizeof")]
+  property sizeof_sizeof : Int32
+end
+
+class StructClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "struct")]
+  property struct_struct : Int32
+end
+
+class Super
+  include JSON::Serializable
+
+  @[JSON::Field(key: "super")]
+  property super_super : Int32
+end
+
+class Then
+  include JSON::Serializable
+
+  @[JSON::Field(key: "then")]
+  property then_then : Int32
+end
+
+class True
+  include JSON::Serializable
+
+  @[JSON::Field(key: "True")]
+  property true_true : Int32
+end
+
+class Type
+  include JSON::Serializable
+
+  @[JSON::Field(key: "Type")]
+  property type_type : Int32
+end
+
+class Typeof
+  include JSON::Serializable
+
+  @[JSON::Field(key: "typeof")]
+  property typeof_typeof : Int32
+end
+
+class Public
+  include JSON::Serializable
+
+  property public : Int32
+end
+
+class SelfClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "self")]
+  property self_self : Int32
+end
+
+class TrueClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "true")]
+  property true_true : Int32
+end
+
+class TypeClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property type_type : Int32
+end
+
+class Quicktype
+  include JSON::Serializable
+
+  property quicktype : Int32
+end
+
+class Raise
+  include JSON::Serializable
+
+  property raise : Int32
+end
+
+class RangeClass
+  include JSON::Serializable
+
+  property range : Int32
+end
+
+class Readonly
+  include JSON::Serializable
+
+  property readonly : Int32
+end
+
+class Ref
+  include JSON::Serializable
+
+  property ref : Int32
+end
+
+class Register
+  include JSON::Serializable
+
+  property register : Int32
+end
+
+class ReinterpretCast
+  include JSON::Serializable
+
+  property reinterpret_cast : Int32
+end
+
+class Repeat
+  include JSON::Serializable
+
+  property repeat : Int32
+end
+
+class Required
+  include JSON::Serializable
+
+  property required : Int32
+end
+
+class Requires
+  include JSON::Serializable
+
+  property requires : Int32
+end
+
+class Restrict
+  include JSON::Serializable
+
+  property restrict : Int32
+end
+
+class Retain
+  include JSON::Serializable
+
+  property retain : Int32
+end
+
+class Rethrows
+  include JSON::Serializable
+
+  property rethrows : Int32
+end
+
+class Right
+  include JSON::Serializable
+
+  property right : Int32
+end
+
+class Sbyte
+  include JSON::Serializable
+
+  property sbyte : Int32
+end
+
+class Sealed
+  include JSON::Serializable
+
+  property sealed : Int32
+end
+
+class Sel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "SEL")]
+  property sel : Int32
+end
+
+class Serialize
+  include JSON::Serializable
+
+  property serialize : Int32
+end
+
+class SetClass
+  include JSON::Serializable
+
+  property set : Int32
+end
+
+class Short
+  include JSON::Serializable
+
+  property short : Int32
+end
+
+class Signed
+  include JSON::Serializable
+
+  property signed : Int32
+end
+
+class Stackalloc
+  include JSON::Serializable
+
+  property stackalloc : Int32
+end
+
+class Static
+  include JSON::Serializable
+
+  property static : Int32
+end
+
+class StaticAssert
+  include JSON::Serializable
+
+  property static_assert : Int32
+end
+
+class StaticCast
+  include JSON::Serializable
+
+  property static_cast : Int32
+end
+
+class Strictfp
+  include JSON::Serializable
+
+  property strictfp : Int32
+end
+
+class StringClass
+  include JSON::Serializable
+
+  property string : Int32
+end
+
+class Subscript
+  include JSON::Serializable
+
+  property subscript : Int32
+end
+
+class Switch
+  include JSON::Serializable
+
+  property switch : Int32
+end
+
+class SymbolClass
+  include JSON::Serializable
+
+  property symbol : Int32
+end
+
+class Synchronized
+  include JSON::Serializable
+
+  property synchronized : Int32
+end
+
+class SystemClass
+  include JSON::Serializable
+
+  property system : Int32
+end
+
+class Template
+  include JSON::Serializable
+
+  property template : Int32
+end
+
+class This
+  include JSON::Serializable
+
+  property this : Int32
+end
+
+class ThreadLocalClass
+  include JSON::Serializable
+
+  property thread_local : Int32
+end
+
+class Throw
+  include JSON::Serializable
+
+  property throw : Int32
+end
+
+class Throws
+  include JSON::Serializable
+
+  property throws : Int32
+end
+
+class ToJson
+  include JSON::Serializable
+
+  property to_json : Int32
+end
+
+class TopLevelClass
+  include JSON::Serializable
+
+  property top_level : Int32
+end
+
+class Transient
+  include JSON::Serializable
+
+  property transient : Int32
+end
+
+class Try
+  include JSON::Serializable
+
+  property try : Int32
+end
+
+class Typealias
+  include JSON::Serializable
+
+  property typealias : Int32
+end
+
+class Typedef
+  include JSON::Serializable
+
+  property typedef : Int32
+end
+
+class Typeid
+  include JSON::Serializable
+
+  property typeid : Int32
+end
+
+class Typename
+  include JSON::Serializable
+
+  property typename : Int32
+end
+
+class Uint
+  include JSON::Serializable
+
+  property uint : Int32
+end
+
+class Ulong
+  include JSON::Serializable
+
+  property ulong : Int32
+end
+
+class Unchecked
+  include JSON::Serializable
+
+  property unchecked : Int32
+end
+
+class Undefined
+  include JSON::Serializable
+
+  property undefined : Int32
+end
+
+class Obj5
+  include JSON::Serializable
+
+  property dummy : Int32
+
+  @[JSON::Field(key: "union")]
+  property obj5_union : UnionClass
+
+  @[JSON::Field(key: "while")]
+  property obj5_while : While
+
+  @[JSON::Field(key: "with")]
+  property obj5_with : With
+
+  @[JSON::Field(key: "yield")]
+  property obj5_yield : Yield
+
+  property unowned : Unowned
+
+  property unsafe : Unsafe
+
+  property unsigned : Unsigned
+
+  property ushort : Ushort
+
+  property using : Using
+
+  property var : Var
+
+  property virtual : Virtual
+
+  property void : VoidClass
+
+  property volatile : Volatile
+
+  property wchar_t : WcharT
+
+  property weak : Weak
+
+  property where : Where
+
+  @[JSON::Field(key: "willSet")]
+  property will_set : WillSet
+
+  property xor : Xor
+
+  property xor_eq : XorEq
+
+  @[JSON::Field(key: "YES")]
+  property yes : Yes
+end
+
+class UnionClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "union")]
+  property union_union : Int32
+end
+
+class While
+  include JSON::Serializable
+
+  @[JSON::Field(key: "while")]
+  property while_while : Int32
+end
+
+class With
+  include JSON::Serializable
+
+  @[JSON::Field(key: "with")]
+  property with_with : Int32
+end
+
+class Yield
+  include JSON::Serializable
+
+  @[JSON::Field(key: "yield")]
+  property yield_yield : Int32
+end
+
+class Unowned
+  include JSON::Serializable
+
+  property unowned : Int32
+end
+
+class Unsafe
+  include JSON::Serializable
+
+  property unsafe : Int32
+end
+
+class Unsigned
+  include JSON::Serializable
+
+  property unsigned : Int32
+end
+
+class Ushort
+  include JSON::Serializable
+
+  property ushort : Int32
+end
+
+class Using
+  include JSON::Serializable
+
+  property using : Int32
+end
+
+class Var
+  include JSON::Serializable
+
+  property var : Int32
+end
+
+class Virtual
+  include JSON::Serializable
+
+  property virtual : Int32
+end
+
+class VoidClass
+  include JSON::Serializable
+
+  property void : Int32
+end
+
+class Volatile
+  include JSON::Serializable
+
+  property volatile : Int32
+end
+
+class WcharT
+  include JSON::Serializable
+
+  property wchar_t : Int32
+end
+
+class Weak
+  include JSON::Serializable
+
+  property weak : Int32
+end
+
+class Where
+  include JSON::Serializable
+
+  property where : Int32
+end
+
+class WillSet
+  include JSON::Serializable
+
+  @[JSON::Field(key: "willSet")]
+  property will_set : Int32
+end
+
+class Xor
+  include JSON::Serializable
+
+  property xor : Int32
+end
+
+class XorEq
+  include JSON::Serializable
+
+  property xor_eq : Int32
+end
+
+class Yes
+  include JSON::Serializable
+
+  @[JSON::Field(key: "YES")]
+  property yes : Int32
+end
diff --git a/head/crystal/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.cr
new file mode 100644
index 0000000..41a4e6c
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property category : String
+end
diff --git a/head/crystal/test/inputs/json/priority/list.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/list.json/default/TopLevel.cr
new file mode 100644
index 0000000..af012e8
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/list.json/default/TopLevel.cr
@@ -0,0 +1,10 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Int32
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : TopLevel?
+end
diff --git a/head/crystal/test/inputs/json/priority/name-style.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/name-style.json/default/TopLevel.cr
new file mode 100644
index 0000000..098d0fc
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/name-style.json/default/TopLevel.cr
@@ -0,0 +1,25 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "anEasyOne")]
+  property an_easy_one : Int32
+
+  @[JSON::Field(key: "isMNISTLetter")]
+  property is_mnist_letter : Bool
+
+  @[JSON::Field(key: "JSONString")]
+  property json_string : String
+
+  @[JSON::Field(key: "PrettyEasyToo")]
+  property pretty_easy_too : Bool
+
+  property should_know_that_id_is_an_initialism : String
+
+  @[JSON::Field(key: "   spaces are separators  too  ")]
+  property spaces_are_separators_too : Bool
+
+  @[JSON::Field(key: "ZSR_HH_DEMO3_DELMATNR")]
+  property zsr_hh_demo3_delmatnr : Bool
+end
diff --git a/head/crystal/test/inputs/json/priority/nbl-stats.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/nbl-stats.json/default/TopLevel.cr
new file mode 100644
index 0000000..ddac0cb
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/nbl-stats.json/default/TopLevel.cr
@@ -0,0 +1,647 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property attendance : Int32
+
+  property clock : String
+
+  @[JSON::Field(key: "disableMatch")]
+  property disable_match : Int32
+
+  @[JSON::Field(key: "inOT")]
+  property in_ot : Int32
+
+  property leaddata : Array(Array(LeaddatumElement))
+
+  property officials_referee1 : String
+
+  property officials_referee2 : String
+
+  property officials_referee3 : String
+
+  property othermatches : Array(Othermatch)
+
+  property pbp : Array(Pbp)
+
+  property period : Int32
+
+  @[JSON::Field(key: "periodLengthOVERTIME")]
+  property period_length_overtime : Int32
+
+  @[JSON::Field(key: "periodLengthREGULAR")]
+  property period_length_regular : Int32
+
+  @[JSON::Field(key: "periodType")]
+  property period_type : String
+
+  @[JSON::Field(key: "periodsMax")]
+  property periods_max : Int32
+
+  property scorers : Hash(String, Array(Scorer))
+
+  property timeline : Array(JSON::Any?)
+
+  property tm : Hash(String, Tm)
+
+  @[JSON::Field(key: "totalTimeAdded")]
+  property total_time_added : Int32
+
+  property totallds : Totallds
+end
+
+class Othermatch
+  include JSON::Serializable
+
+  property clock : String
+
+  @[JSON::Field(key: "competitionName")]
+  property competition_name : String
+
+  property id : String
+
+  property period : Int32
+
+  @[JSON::Field(key: "periodType")]
+  property period_type : String
+
+  property team1 : Team
+
+  @[JSON::Field(key: "team1Name")]
+  property team1_name : String
+
+  @[JSON::Field(key: "team1Score")]
+  property team1_score : Int32
+
+  property team2 : Team
+
+  @[JSON::Field(key: "team2Name")]
+  property team2_name : String
+
+  @[JSON::Field(key: "team2Score")]
+  property team2_score : Int32
+end
+
+class Team
+  include JSON::Serializable
+
+  @[JSON::Field(key: "teamCode")]
+  property team_code : String
+
+  @[JSON::Field(key: "teamCodeInternational")]
+  property team_code_international : String
+
+  @[JSON::Field(key: "teamName")]
+  property team_name : String
+
+  @[JSON::Field(key: "teamNameInternational")]
+  property team_name_international : String
+end
+
+class Pbp
+  include JSON::Serializable
+
+  @[JSON::Field(key: "actionType")]
+  property action_type : String
+
+  @[JSON::Field(key: "familyName")]
+  property family_name : String?
+
+  @[JSON::Field(key: "familyNameInitial")]
+  property family_name_initial : String?
+
+  @[JSON::Field(key: "firstName")]
+  property first_name : String?
+
+  @[JSON::Field(key: "firstNameInitial")]
+  property first_name_initial : String?
+
+  property gt : String
+
+  @[JSON::Field(key: "internationalFamilyName")]
+  property international_family_name : String?
+
+  @[JSON::Field(key: "internationalFamilyNameInitial")]
+  property international_family_name_initial : String?
+
+  @[JSON::Field(key: "internationalFirstName")]
+  property international_first_name : String?
+
+  @[JSON::Field(key: "internationalFirstNameInitial")]
+  property international_first_name_initial : String?
+
+  property lead : Int32
+
+  property period : Int32
+
+  @[JSON::Field(key: "periodType")]
+  property period_type : String
+
+  property player : String
+
+  property pno : Int32
+
+  property qualifier : String
+
+  property s1 : Int32
+
+  property s2 : Int32
+
+  @[JSON::Field(key: "scoreboardName")]
+  property scoreboard_name : String?
+
+  property scoring : Int32
+
+  @[JSON::Field(key: "shirtNumber")]
+  property shirt_number : String
+
+  @[JSON::Field(key: "subType")]
+  property sub_type : String
+
+  property success : Int32
+
+  property tno : Int32
+end
+
+class Scorer
+  include JSON::Serializable
+
+  @[JSON::Field(key: "familyName")]
+  property family_name : String?
+
+  @[JSON::Field(key: "familyNameInitial")]
+  property family_name_initial : String?
+
+  @[JSON::Field(key: "firstName")]
+  property first_name : String?
+
+  @[JSON::Field(key: "firstNameInitial")]
+  property first_name_initial : String?
+
+  property gt : String?
+
+  @[JSON::Field(key: "internationalFamilyName")]
+  property international_family_name : String?
+
+  @[JSON::Field(key: "internationalFamilyNameInitial")]
+  property international_family_name_initial : String?
+
+  @[JSON::Field(key: "internationalFirstName")]
+  property international_first_name : String?
+
+  @[JSON::Field(key: "internationalFirstNameInitial")]
+  property international_first_name_initial : String?
+
+  property name : String?
+
+  property per : Int32?
+
+  @[JSON::Field(key: "perType")]
+  property per_type : String?
+
+  property player : String?
+
+  property pno : Int32
+
+  @[JSON::Field(key: "scoreboardName")]
+  property scoreboard_name : String?
+
+  @[JSON::Field(key: "shirtNumber")]
+  property shirt_number : String
+
+  property summary : String?
+
+  property times : Array(TimeElement)?
+
+  property tno : Int32
+
+  property tot : Int32?
+end
+
+class TimeElement
+  include JSON::Serializable
+
+  property gt : String
+
+  property per : Int32
+
+  @[JSON::Field(key: "perType")]
+  property per_type : String
+end
+
+class Tm
+  include JSON::Serializable
+
+  property code : String
+
+  @[JSON::Field(key: "codeInternational")]
+  property code_international : String
+
+  property fouls : Int32
+
+  property full_score : Int32
+
+  property lds : Lds
+
+  property logo : String
+
+  property name : String
+
+  @[JSON::Field(key: "nameInternational")]
+  property name_international : String
+
+  property p1_score : Int32
+
+  property p2_score : Int32
+
+  property p3_score : Int32
+
+  property p4_score : Int32
+
+  property pl : Hash(String, Pl)
+
+  property score : Int32
+
+  property scoring : Array(Scorer)
+
+  @[JSON::Field(key: "shortName")]
+  property short_name : String
+
+  @[JSON::Field(key: "shortNameInternational")]
+  property short_name_international : String
+
+  property shot : Array(Shot)
+
+  property timeouts : Int32
+
+  property tot_eff_1 : Int32
+
+  property tot_eff_2 : Int32
+
+  property tot_eff_3 : Float64
+
+  property tot_eff_4 : Int32
+
+  property tot_eff_5 : Int32
+
+  property tot_eff_6 : Int32
+
+  property tot_eff_7 : Int32
+
+  @[JSON::Field(key: "tot_sAssists")]
+  property tot_s_assists : Int32
+
+  @[JSON::Field(key: "tot_sBenchPoints")]
+  property tot_s_bench_points : Int32
+
+  @[JSON::Field(key: "tot_sBiggestLead")]
+  property tot_s_biggest_lead : Int32
+
+  @[JSON::Field(key: "tot_sBiggestScoringRun")]
+  property tot_s_biggest_scoring_run : Int32
+
+  @[JSON::Field(key: "tot_sBlocks")]
+  property tot_s_blocks : Int32
+
+  @[JSON::Field(key: "tot_sBlocksReceived")]
+  property tot_s_blocks_received : Int32
+
+  @[JSON::Field(key: "tot_sFieldGoalsAttempted")]
+  property tot_s_field_goals_attempted : Int32
+
+  @[JSON::Field(key: "tot_sFieldGoalsMade")]
+  property tot_s_field_goals_made : Int32
+
+  @[JSON::Field(key: "tot_sFieldGoalsPercentage")]
+  property tot_s_field_goals_percentage : Int32
+
+  @[JSON::Field(key: "tot_sFoulsOn")]
+  property tot_s_fouls_on : Int32
+
+  @[JSON::Field(key: "tot_sFoulsPersonal")]
+  property tot_s_fouls_personal : Int32
+
+  @[JSON::Field(key: "tot_sFoulsTeam")]
+  property tot_s_fouls_team : Int32
+
+  @[JSON::Field(key: "tot_sFreeThrowsAttempted")]
+  property tot_s_free_throws_attempted : Int32
+
+  @[JSON::Field(key: "tot_sFreeThrowsMade")]
+  property tot_s_free_throws_made : Int32
+
+  @[JSON::Field(key: "tot_sFreeThrowsPercentage")]
+  property tot_s_free_throws_percentage : Int32
+
+  @[JSON::Field(key: "tot_sLeadChanges")]
+  property tot_s_lead_changes : Int32
+
+  @[JSON::Field(key: "tot_sMinutes")]
+  property tot_s_minutes : Int32
+
+  @[JSON::Field(key: "tot_sPoints")]
+  property tot_s_points : Int32
+
+  @[JSON::Field(key: "tot_sPointsFastBreak")]
+  property tot_s_points_fast_break : Int32
+
+  @[JSON::Field(key: "tot_sPointsFromTurnovers")]
+  property tot_s_points_from_turnovers : Int32
+
+  @[JSON::Field(key: "tot_sPointsInThePaint")]
+  property tot_s_points_in_the_paint : Int32
+
+  @[JSON::Field(key: "tot_sPointsSecondChance")]
+  property tot_s_points_second_chance : Int32
+
+  @[JSON::Field(key: "tot_sReboundsDefensive")]
+  property tot_s_rebounds_defensive : Int32
+
+  @[JSON::Field(key: "tot_sReboundsOffensive")]
+  property tot_s_rebounds_offensive : Int32
+
+  @[JSON::Field(key: "tot_sReboundsTeam")]
+  property tot_s_rebounds_team : Int32
+
+  @[JSON::Field(key: "tot_sReboundsTeamDefensive")]
+  property tot_s_rebounds_team_defensive : Int32
+
+  @[JSON::Field(key: "tot_sReboundsTeamOffensive")]
+  property tot_s_rebounds_team_offensive : Int32
+
+  @[JSON::Field(key: "tot_sReboundsTotal")]
+  property tot_s_rebounds_total : Int32
+
+  @[JSON::Field(key: "tot_sSteals")]
+  property tot_s_steals : Int32
+
+  @[JSON::Field(key: "tot_sThreePointersAttempted")]
+  property tot_s_three_pointers_attempted : Int32
+
+  @[JSON::Field(key: "tot_sThreePointersMade")]
+  property tot_s_three_pointers_made : Int32
+
+  @[JSON::Field(key: "tot_sThreePointersPercentage")]
+  property tot_s_three_pointers_percentage : Int32
+
+  @[JSON::Field(key: "tot_sTimeLeading")]
+  property tot_s_time_leading : Float64
+
+  @[JSON::Field(key: "tot_sTimesScoresLevel")]
+  property tot_s_times_scores_level : Int32
+
+  @[JSON::Field(key: "tot_sTurnovers")]
+  property tot_s_turnovers : Int32
+
+  @[JSON::Field(key: "tot_sTurnoversTeam")]
+  property tot_s_turnovers_team : Int32
+
+  @[JSON::Field(key: "tot_sTwoPointersAttempted")]
+  property tot_s_two_pointers_attempted : Int32
+
+  @[JSON::Field(key: "tot_sTwoPointersMade")]
+  property tot_s_two_pointers_made : Int32
+
+  @[JSON::Field(key: "tot_sTwoPointersPercentage")]
+  property tot_s_two_pointers_percentage : Int32
+end
+
+class Lds
+  include JSON::Serializable
+
+  @[JSON::Field(key: "sAssists")]
+  property s_assists : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sBlocks")]
+  property s_blocks : SBlocks
+
+  @[JSON::Field(key: "sPoints")]
+  property s_points : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sReboundsTotal")]
+  property s_rebounds_total : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sSteals")]
+  property s_steals : Hash(String, Scorer)
+end
+
+class SBlocks
+  include JSON::Serializable
+
+  @[JSON::Field(key: "1")]
+  property the_1 : Scorer
+end
+
+class Pl
+  include JSON::Serializable
+
+  property active : Int32
+
+  property captain : Int32?
+
+  property comp : Comp?
+
+  property eff_1 : Int32
+
+  property eff_2 : Int32
+
+  property eff_3 : Float64
+
+  property eff_4 : Float64
+
+  property eff_5 : Int32
+
+  property eff_6 : Int32
+
+  property eff_7 : Int32
+
+  @[JSON::Field(key: "familyName")]
+  property family_name : String
+
+  @[JSON::Field(key: "familyNameInitial")]
+  property family_name_initial : String
+
+  @[JSON::Field(key: "firstName")]
+  property first_name : String
+
+  @[JSON::Field(key: "firstNameInitial")]
+  property first_name_initial : String
+
+  @[JSON::Field(key: "internationalFamilyName")]
+  property international_family_name : String
+
+  @[JSON::Field(key: "internationalFamilyNameInitial")]
+  property international_family_name_initial : String
+
+  @[JSON::Field(key: "internationalFirstName")]
+  property international_first_name : String
+
+  @[JSON::Field(key: "internationalFirstNameInitial")]
+  property international_first_name_initial : String
+
+  property name : String
+
+  @[JSON::Field(key: "playingPosition")]
+  property playing_position : String
+
+  @[JSON::Field(key: "sAssists")]
+  property s_assists : Int32
+
+  @[JSON::Field(key: "sBlocks")]
+  property s_blocks : Int32
+
+  @[JSON::Field(key: "sBlocksReceived")]
+  property s_blocks_received : Int32
+
+  @[JSON::Field(key: "sFieldGoalsAttempted")]
+  property s_field_goals_attempted : Int32
+
+  @[JSON::Field(key: "sFieldGoalsMade")]
+  property s_field_goals_made : Int32
+
+  @[JSON::Field(key: "sFieldGoalsPercentage")]
+  property s_field_goals_percentage : Int32
+
+  @[JSON::Field(key: "sFoulsOn")]
+  property s_fouls_on : Int32
+
+  @[JSON::Field(key: "sFoulsPersonal")]
+  property s_fouls_personal : Int32
+
+  @[JSON::Field(key: "sFreeThrowsAttempted")]
+  property s_free_throws_attempted : Int32
+
+  @[JSON::Field(key: "sFreeThrowsMade")]
+  property s_free_throws_made : Int32
+
+  @[JSON::Field(key: "sFreeThrowsPercentage")]
+  property s_free_throws_percentage : Int32
+
+  @[JSON::Field(key: "sMinutes")]
+  property s_minutes : SMinutes
+
+  @[JSON::Field(key: "sPlusMinusPoints")]
+  property s_plus_minus_points : Int32
+
+  @[JSON::Field(key: "sPoints")]
+  property s_points : Int32
+
+  @[JSON::Field(key: "sPointsFastBreak")]
+  property s_points_fast_break : Int32
+
+  @[JSON::Field(key: "sPointsInThePaint")]
+  property s_points_in_the_paint : Int32
+
+  @[JSON::Field(key: "sPointsSecondChance")]
+  property s_points_second_chance : Int32
+
+  @[JSON::Field(key: "sReboundsDefensive")]
+  property s_rebounds_defensive : Int32
+
+  @[JSON::Field(key: "sReboundsOffensive")]
+  property s_rebounds_offensive : Int32
+
+  @[JSON::Field(key: "sReboundsTotal")]
+  property s_rebounds_total : Int32
+
+  @[JSON::Field(key: "sSteals")]
+  property s_steals : Int32
+
+  @[JSON::Field(key: "sThreePointersAttempted")]
+  property s_three_pointers_attempted : Int32
+
+  @[JSON::Field(key: "sThreePointersMade")]
+  property s_three_pointers_made : Int32
+
+  @[JSON::Field(key: "sThreePointersPercentage")]
+  property s_three_pointers_percentage : Int32
+
+  @[JSON::Field(key: "sTurnovers")]
+  property s_turnovers : Int32
+
+  @[JSON::Field(key: "sTwoPointersAttempted")]
+  property s_two_pointers_attempted : Int32
+
+  @[JSON::Field(key: "sTwoPointersMade")]
+  property s_two_pointers_made : Int32
+
+  @[JSON::Field(key: "sTwoPointersPercentage")]
+  property s_two_pointers_percentage : Int32
+
+  @[JSON::Field(key: "shirtNumber")]
+  property shirt_number : String
+
+  property starter : Int32
+end
+
+class Comp
+  include JSON::Serializable
+
+  @[JSON::Field(key: "sAssistsAverage")]
+  property s_assists_average : Float64
+
+  @[JSON::Field(key: "sMinutesAverage")]
+  property s_minutes_average : String
+
+  @[JSON::Field(key: "sPointsAverage")]
+  property s_points_average : Float64
+
+  @[JSON::Field(key: "sReboundsTotalAverage")]
+  property s_rebounds_total_average : Float64
+end
+
+class Shot
+  include JSON::Serializable
+
+  @[JSON::Field(key: "actionType")]
+  property action_type : String
+
+  property p : Int32
+
+  property per : Int32
+
+  @[JSON::Field(key: "perType")]
+  property per_type : String
+
+  property player : String
+
+  property pno : Int32
+
+  property r : Int32
+
+  @[JSON::Field(key: "shirtNumber")]
+  property shirt_number : String
+
+  @[JSON::Field(key: "subType")]
+  property sub_type : String
+
+  property tno : Int32
+
+  property x : Int32
+
+  property y : Int32
+end
+
+class Totallds
+  include JSON::Serializable
+
+  @[JSON::Field(key: "sAssists")]
+  property s_assists : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sBlocks")]
+  property s_blocks : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sPoints")]
+  property s_points : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sReboundsTotal")]
+  property s_rebounds_total : Hash(String, Scorer)
+
+  @[JSON::Field(key: "sSteals")]
+  property s_steals : Hash(String, Scorer)
+end
+
+alias LeaddatumElement = Int32 | String
+
+alias SMinutes = Int32 | String
diff --git a/head/crystal/test/inputs/json/priority/nested-objects.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/nested-objects.json/default/TopLevel.cr
new file mode 100644
index 0000000..28cf867
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/nested-objects.json/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property a : Hash(String, Int32)
+
+  property b : Hash(String, Int32)
+end
diff --git a/head/crystal/test/inputs/json/priority/no-classes.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/no-classes.json/default/TopLevel.cr
new file mode 100644
index 0000000..d47e0bf
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/no-classes.json/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Int32
diff --git a/head/crystal/test/inputs/json/priority/number-map.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/number-map.json/default/TopLevel.cr
new file mode 100644
index 0000000..84f5417
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/number-map.json/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Hash(String, Float64)
+end
diff --git a/head/crystal/test/inputs/json/priority/omit-empty.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/omit-empty.json/default/TopLevel.cr
new file mode 100644
index 0000000..d1e7044
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/omit-empty.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property results : Array(Result)
+end
+
+class Result
+  include JSON::Serializable
+
+  property age : Int32
+
+  property name : Nil
+end
diff --git a/head/crystal/test/inputs/json/priority/optional-union.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/optional-union.json/default/TopLevel.cr
new file mode 100644
index 0000000..238db97
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/optional-union.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property a : A?
+end
+
+alias A = Int32 | String
diff --git a/head/crystal/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.cr
new file mode 100644
index 0000000..4c9d8fc
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property mixed : Array(MixedElement?)
+end
+
+class MixedClass
+  include JSON::Serializable
+
+  property nested : String
+end
+
+alias MixedElement = Int32 | MixedClass | Bool | String
diff --git a/head/crystal/test/inputs/json/priority/php-validation.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/php-validation.json/default/TopLevel.cr
new file mode 100644
index 0000000..1bbf448
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/php-validation.json/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property boolean : Bool
+
+  property integer : Int32
+
+  property integers : Array(Int32)
+
+  property number : Float64
+
+  property string : String
+end
diff --git a/head/crystal/test/inputs/json/priority/recursive.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/recursive.json/default/TopLevel.cr
new file mode 100644
index 0000000..3de7f98
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/recursive.json/default/TopLevel.cr
@@ -0,0 +1,214 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property category : Category
+
+  property details : Details
+
+  property match : String
+
+  property page : Int32
+
+  property product : Array(ProductElement)
+
+  property schk : Bool
+
+  property totallooseoffers : Int32
+
+  property totalpages : Int32
+
+  property totalresultsavailable : Int32
+
+  property totalresultsreturned : Int32
+end
+
+class Category
+  include JSON::Serializable
+
+  property concatenatecategoryname : Bool
+
+  property hasoffer : Bool
+
+  property id : Int32
+
+  property isfinal : Bool
+
+  property links : Array(LinkElement)
+
+  property name : String
+
+  property parentcategoryid : Int32
+
+  property thumbnail : CategoryThumbnail
+end
+
+class LinkElement
+  include JSON::Serializable
+
+  property link : LinkLink
+end
+
+class LinkLink
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property link_type : String
+
+  property url : String
+end
+
+class CategoryThumbnail
+  include JSON::Serializable
+
+  property url : String
+end
+
+class Details
+  include JSON::Serializable
+
+  property applicationid : String
+
+  property applicationversion : String
+
+  property code : Int32
+
+  property date : Date
+
+  property elapsedtime : Int32
+
+  property message : String
+
+  property status : String
+end
+
+class Date
+  include JSON::Serializable
+
+  property day : Int32
+
+  property eonandyear : Eonandyear
+
+  property hour : Int32
+
+  property millisecond : Int32
+
+  property minute : Int32
+
+  property month : Int32
+
+  property second : Int32
+
+  property timezone : Int32
+
+  property valid : Bool
+
+  property xmlschematype : Xmlschematype
+
+  property year : Int32
+end
+
+class Eonandyear
+  include JSON::Serializable
+
+  property lowestsetbit : Int32
+end
+
+class Xmlschematype
+  include JSON::Serializable
+
+  property localpart : String
+
+  property namespaceuri : String
+
+  property prefix : String
+end
+
+class ProductElement
+  include JSON::Serializable
+
+  property product : ProductProduct
+end
+
+class ProductProduct
+  include JSON::Serializable
+
+  property categoryid : Int32
+
+  property currency : Currency
+
+  property eco : Bool
+
+  property fulldescription : Bool
+
+  property hasmetasearch : Bool
+
+  property id : Int32
+
+  property links : Array(LinkElement)
+
+  property numoffers : Int32
+
+  property pricemax : String
+
+  property pricemin : String
+
+  property productname : String
+
+  property quantity : Int32
+
+  property rating : Rating
+
+  property specification : Specification
+
+  property thumbnail : FormatsClass
+
+  property totalsellers : Int32
+end
+
+class Currency
+  include JSON::Serializable
+
+  property abbreviation : String
+end
+
+class Rating
+  include JSON::Serializable
+
+  property useraveragerating : Useraveragerating
+end
+
+class Useraveragerating
+  include JSON::Serializable
+
+  property links : Array(LinkElement)
+
+  property numcomments : Int32
+
+  property rating : String
+end
+
+class Specification
+  include JSON::Serializable
+
+  property links : Array(LinkElement)
+end
+
+class Format
+  include JSON::Serializable
+
+  property formats : FormatsClass
+end
+
+class FormatsClass
+  include JSON::Serializable
+
+  property formats : Array(Format)?
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
diff --git a/head/crystal/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.cr
new file mode 100644
index 0000000..da268fe
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "BoolInUnion")]
+  property bool_in_union : BoolInUnion
+
+  @[JSON::Field(key: "union")]
+  property top_level_union : Array(UnionElement)
+end
+
+class BoolInUnion
+  include JSON::Serializable
+
+  property a : Bool
+end
+
+alias UnionElement = Int32 | Bool
diff --git a/head/crystal/test/inputs/json/priority/unions.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/unions.json/default/TopLevel.cr
new file mode 100644
index 0000000..cb5fd12
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/unions.json/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property x : Array(X?)
+
+  property y : Array(Int32?)
+
+  property z : Array(ZElement)
+end
+
+class ZClass
+  include JSON::Serializable
+
+  property a : Bool
+end
+
+alias X = Int32 | String
+
+alias ZElement = Int32 | Array(Int32) | ZClass
diff --git a/head/crystal/test/inputs/json/priority/url.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/url.json/default/TopLevel.cr
new file mode 100644
index 0000000..49f380a
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/url.json/default/TopLevel.cr
@@ -0,0 +1,10 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "fromURL")]
+  property from_url : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/priority/uuids.json/default/TopLevel.cr b/head/crystal/test/inputs/json/priority/uuids.json/default/TopLevel.cr
new file mode 100644
index 0000000..8994464
--- /dev/null
+++ b/head/crystal/test/inputs/json/priority/uuids.json/default/TopLevel.cr
@@ -0,0 +1,23 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "booleanValue")]
+  property boolean_value : Bool
+
+  @[JSON::Field(key: "doubleValue")]
+  property double_value : Float64
+
+  @[JSON::Field(key: "intValue")]
+  property int_value : Int32
+
+  @[JSON::Field(key: "stringValue")]
+  property string_value : String
+
+  @[JSON::Field(key: "uuidValue")]
+  property uuid_value : String
+
+  @[JSON::Field(key: "uuidValues")]
+  property uuid_values : Array(String)
+end
diff --git a/head/crystal/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.cr
new file mode 100644
index 0000000..2ae8da8
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.cr
@@ -0,0 +1,16 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property block_index : Int32
+
+  property hash : String
+
+  property height : Int32
+
+  property time : Int32
+
+  @[JSON::Field(key: "txIndexes")]
+  property tx_indexes : Array(Int32)
+end
diff --git a/head/crystal/test/inputs/json/samples/getting-started.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/getting-started.json/default/TopLevel.cr
new file mode 100644
index 0000000..ec0464a
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/getting-started.json/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property greeting : String
+
+  property instructions : Array(String)
+end
diff --git a/head/crystal/test/inputs/json/samples/github-events.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/github-events.json/default/TopLevel.cr
new file mode 100644
index 0000000..0995433
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/github-events.json/default/TopLevel.cr
@@ -0,0 +1,546 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property actor : Actor
+
+  property created_at : String
+
+  property id : String
+
+  property org : Actor?
+
+  property payload : Payload
+
+  property public : Bool
+
+  property repo : TopLevelRepo
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+end
+
+class Actor
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property display_login : String?
+
+  property gravatar_id : String
+
+  property id : Int32
+
+  property login : String
+
+  property url : String
+end
+
+class Payload
+  include JSON::Serializable
+
+  property action : String?
+
+  property before : String?
+
+  property comment : Comment?
+
+  property commits : Array(Commit)?
+
+  property description : String?
+
+  property distinct_size : Int32?
+
+  property head : String?
+
+  property issue : Issue?
+
+  property master_branch : String?
+
+  property number : Int32?
+
+  property pull_request : PayloadPullRequest?
+
+  property push_id : Int32?
+
+  property pusher_type : String?
+
+  property ref : String?
+
+  property ref_type : String?
+
+  property size : Int32?
+end
+
+class Comment
+  include JSON::Serializable
+
+  property body : String
+
+  property created_at : String
+
+  property html_url : String
+
+  property id : Int32
+
+  property issue_url : String
+
+  property updated_at : String
+
+  property url : String
+
+  property user : User
+end
+
+class User
+  include JSON::Serializable
+
+  property avatar_url : String
+
+  property events_url : String
+
+  property followers_url : String
+
+  property following_url : String
+
+  property gists_url : String
+
+  property gravatar_id : String
+
+  property html_url : String
+
+  property id : Int32
+
+  property login : String
+
+  property organizations_url : String
+
+  property received_events_url : String
+
+  property repos_url : String
+
+  property site_admin : Bool
+
+  property starred_url : String
+
+  property subscriptions_url : String
+
+  property url : String
+
+  @[JSON::Field(key: "type")]
+  property user_type : String
+end
+
+class Commit
+  include JSON::Serializable
+
+  property author : Author
+
+  property distinct : Bool
+
+  property message : String
+
+  property sha : String
+
+  property url : String
+end
+
+class Author
+  include JSON::Serializable
+
+  property email : String
+
+  property name : String
+end
+
+class Issue
+  include JSON::Serializable
+
+  property assignee : Nil
+
+  property assignees : Array(JSON::Any?)
+
+  property body : String
+
+  property closed_at : String?
+
+  property comments : Int32
+
+  property comments_url : String
+
+  property created_at : String
+
+  property events_url : String
+
+  property html_url : String
+
+  property id : Int32
+
+  property labels : Array(Label)
+
+  property labels_url : String
+
+  property locked : Bool
+
+  property milestone : Milestone?
+
+  property number : Int32
+
+  property pull_request : IssuePullRequest?
+
+  property repository_url : String
+
+  property state : String
+
+  property title : String
+
+  property updated_at : String
+
+  property url : String
+
+  property user : User
+end
+
+class Label
+  include JSON::Serializable
+
+  property color : String
+
+  property default : Bool
+
+  property id : Int32
+
+  property name : String
+
+  property url : String
+end
+
+class Milestone
+  include JSON::Serializable
+
+  property closed_at : Nil
+
+  property closed_issues : Int32
+
+  property created_at : String
+
+  property creator : User
+
+  property description : String
+
+  property due_on : String?
+
+  property html_url : String
+
+  property id : Int32
+
+  property labels_url : String
+
+  property number : Int32
+
+  property open_issues : Int32
+
+  property state : String
+
+  property title : String
+
+  property updated_at : String
+
+  property url : String
+end
+
+class IssuePullRequest
+  include JSON::Serializable
+
+  property diff_url : String
+
+  property html_url : String
+
+  property patch_url : String
+
+  property url : String
+end
+
+class PayloadPullRequest
+  include JSON::Serializable
+
+  property additions : Int32
+
+  property assignee : Nil
+
+  property assignees : Array(JSON::Any?)
+
+  property base : Base
+
+  property body : String
+
+  property changed_files : Int32
+
+  property closed_at : String
+
+  property comments : Int32
+
+  property comments_url : String
+
+  property commits : Int32
+
+  property commits_url : String
+
+  property created_at : String
+
+  property deletions : Int32
+
+  property diff_url : String
+
+  property head : Base
+
+  property html_url : String
+
+  property id : Int32
+
+  property issue_url : String
+
+  @[JSON::Field(key: "_links")]
+  property links : Links
+
+  property locked : Bool
+
+  property maintainer_can_modify : Bool
+
+  property merge_commit_sha : String
+
+  property mergeable : Nil
+
+  property mergeable_state : String
+
+  property merged : Bool
+
+  property merged_at : String
+
+  property merged_by : User
+
+  property milestone : Nil
+
+  property number : Int32
+
+  property patch_url : String
+
+  property rebaseable : Nil
+
+  property requested_reviewers : Array(JSON::Any?)
+
+  property review_comment_url : String
+
+  property review_comments : Int32
+
+  property review_comments_url : String
+
+  property state : String
+
+  property statuses_url : String
+
+  property title : String
+
+  property updated_at : String
+
+  property url : String
+
+  property user : User
+end
+
+class Base
+  include JSON::Serializable
+
+  property label : String
+
+  property ref : String
+
+  property repo : BaseRepo
+
+  property sha : String
+
+  property user : User
+end
+
+class BaseRepo
+  include JSON::Serializable
+
+  property archive_url : String
+
+  property assignees_url : String
+
+  property blobs_url : String
+
+  property branches_url : String
+
+  property clone_url : String
+
+  property collaborators_url : String
+
+  property comments_url : String
+
+  property commits_url : String
+
+  property compare_url : String
+
+  property contents_url : String
+
+  property contributors_url : String
+
+  property created_at : String
+
+  property default_branch : String
+
+  property deployments_url : String
+
+  property description : String
+
+  property downloads_url : String
+
+  property events_url : String
+
+  property fork : Bool
+
+  property forks : Int32
+
+  property forks_count : Int32
+
+  property forks_url : String
+
+  property full_name : String
+
+  property git_commits_url : String
+
+  property git_refs_url : String
+
+  property git_tags_url : String
+
+  property git_url : String
+
+  property has_downloads : Bool
+
+  property has_issues : Bool
+
+  property has_pages : Bool
+
+  property has_projects : Bool
+
+  property has_wiki : Bool
+
+  property homepage : String
+
+  property hooks_url : String
+
+  property html_url : String
+
+  property id : Int32
+
+  property issue_comment_url : String
+
+  property issue_events_url : String
+
+  property issues_url : String
+
+  property keys_url : String
+
+  property labels_url : String
+
+  property language : String
+
+  property languages_url : String
+
+  property merges_url : String
+
+  property milestones_url : String
+
+  property mirror_url : Nil
+
+  property name : String
+
+  property notifications_url : String
+
+  property open_issues : Int32
+
+  property open_issues_count : Int32
+
+  property owner : User
+
+  property pulls_url : String
+
+  property pushed_at : String
+
+  property releases_url : String
+
+  @[JSON::Field(key: "private")]
+  property repo_private : Bool
+
+  property size : Int32
+
+  property ssh_url : String
+
+  property stargazers_count : Int32
+
+  property stargazers_url : String
+
+  property statuses_url : String
+
+  property subscribers_url : String
+
+  property subscription_url : String
+
+  property svn_url : String
+
+  property tags_url : String
+
+  property teams_url : String
+
+  property trees_url : String
+
+  property updated_at : String
+
+  property url : String
+
+  property watchers : Int32
+
+  property watchers_count : Int32
+end
+
+class Links
+  include JSON::Serializable
+
+  property comments : Comments
+
+  property commits : Comments
+
+  property html : Comments
+
+  property issue : Comments
+
+  @[JSON::Field(key: "self")]
+  property links_self : Comments
+
+  property review_comment : Comments
+
+  property review_comments : Comments
+
+  property statuses : Comments
+end
+
+class Comments
+  include JSON::Serializable
+
+  property href : String
+end
+
+class TopLevelRepo
+  include JSON::Serializable
+
+  property id : Int32
+
+  property name : String
+
+  property url : String
+end
diff --git a/head/crystal/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.cr
new file mode 100644
index 0000000..67a3e26
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.cr
@@ -0,0 +1,75 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "booleanValue")]
+  property boolean_value : Bool
+
+  @[JSON::Field(key: "dateValue")]
+  property date_value : String
+
+  @[JSON::Field(key: "differentThings")]
+  property different_things : Array(DifferentThingElement)
+
+  @[JSON::Field(key: "doubleValue")]
+  property double_value : Float64
+
+  @[JSON::Field(key: "intValue")]
+  property int_value : Int32
+
+  @[JSON::Field(key: "mapValue")]
+  property map_value : Hash(String, Int32?)
+
+  @[JSON::Field(key: "name with spaces")]
+  property name_with_spaces : Nil
+
+  @[JSON::Field(key: "nullValue")]
+  property null_value : Nil
+
+  @[JSON::Field(key: "nullableMapValue")]
+  property nullable_map_value : Hash(String, Int32?)
+
+  property people : Array(PersonElement)
+
+  property person : PurplePerson
+
+  @[JSON::Field(key: "stringValue")]
+  property string_value : String
+
+  property tuples : Array(Array(IntOrString))
+
+  @[JSON::Field(key: "uuidValue")]
+  property uuid_value : String
+end
+
+class DifferentThingClass
+  include JSON::Serializable
+
+  property name : String
+end
+
+class PersonElement
+  include JSON::Serializable
+
+  @[JSON::Field(key: "intOrString")]
+  property int_or_string : IntOrString
+
+  property name : String
+
+  @[JSON::Field(key: "optionalValue")]
+  property optional_value : Bool?
+end
+
+class PurplePerson
+  include JSON::Serializable
+
+  @[JSON::Field(key: "intOrString")]
+  property int_or_string : Int32
+
+  property name : String
+end
+
+alias DifferentThingElement = DifferentThingClass | Int32 | String
+
+alias IntOrString = Int32 | String
diff --git a/head/crystal/test/inputs/json/samples/null-safe.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/null-safe.json/default/TopLevel.cr
new file mode 100644
index 0000000..7ecc9e4
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/null-safe.json/default/TopLevel.cr
@@ -0,0 +1,29 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property item : Array(Item)
+end
+
+class Item
+  include JSON::Serializable
+
+  property address : Address?
+
+  property created_at : String?
+
+  property name : String
+
+  property sex : Int32?
+end
+
+class Address
+  include JSON::Serializable
+
+  property city : String
+
+  property country : String
+
+  property street : String
+end
diff --git a/head/crystal/test/inputs/json/samples/pokedex.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/pokedex.json/default/TopLevel.cr
new file mode 100644
index 0000000..50f4516
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/pokedex.json/default/TopLevel.cr
@@ -0,0 +1,54 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property pokemon : Array(Pokemon)
+end
+
+class Pokemon
+  include JSON::Serializable
+
+  property avg_spawns : Float64
+
+  property candy : String
+
+  property candy_count : Int32?
+
+  property egg : String
+
+  property height : String
+
+  property id : Int32
+
+  property img : String
+
+  property multipliers : Array(Float64)?
+
+  property name : String
+
+  property next_evolution : Array(Evolution)?
+
+  property num : String
+
+  @[JSON::Field(key: "type")]
+  property pokemon_type : Array(String)
+
+  property prev_evolution : Array(Evolution)?
+
+  property spawn_chance : Float64
+
+  property spawn_time : String
+
+  property weaknesses : Array(String)
+
+  property weight : String
+end
+
+class Evolution
+  include JSON::Serializable
+
+  property name : String
+
+  property num : String
+end
diff --git a/head/crystal/test/inputs/json/samples/reddit.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/reddit.json/default/TopLevel.cr
new file mode 100644
index 0000000..3edffc8
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/reddit.json/default/TopLevel.cr
@@ -0,0 +1,216 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : TopLevelData
+
+  property kind : String
+end
+
+class TopLevelData
+  include JSON::Serializable
+
+  property after : String
+
+  property before : Nil
+
+  property children : Array(Child)
+
+  property modhash : String
+end
+
+class Child
+  include JSON::Serializable
+
+  property data : ChildData
+
+  property kind : String
+end
+
+class ChildData
+  include JSON::Serializable
+
+  property approved_at_utc : Nil
+
+  property approved_by : Nil
+
+  property archived : Bool
+
+  property author : String
+
+  property author_flair_css_class : String?
+
+  property author_flair_text : String?
+
+  property banned_at_utc : Nil
+
+  property banned_by : Nil
+
+  property brand_safe : Bool
+
+  property can_gild : Bool
+
+  property can_mod_post : Bool
+
+  property clicked : Bool
+
+  property contest_mode : Bool
+
+  property created : Int32
+
+  property created_utc : Int32
+
+  property distinguished : String?
+
+  property domain : String
+
+  property downs : Int32
+
+  property edited : Bool
+
+  property gilded : Int32
+
+  property hidden : Bool
+
+  property hide_score : Bool
+
+  property id : String
+
+  property is_self : Bool
+
+  property is_video : Bool
+
+  property likes : Nil
+
+  property link_flair_css_class : String?
+
+  property link_flair_text : String?
+
+  property locked : Bool
+
+  property media : Nil
+
+  property media_embed : MediaEmbed
+
+  property mod_reports : Array(JSON::Any?)
+
+  property name : String
+
+  property num_comments : Int32
+
+  property num_reports : Nil
+
+  property over_18 : Bool
+
+  property parent_whitelist_status : String
+
+  property permalink : String
+
+  property post_hint : String
+
+  property preview : Preview
+
+  property quarantine : Bool
+
+  property removal_reason : Nil
+
+  property report_reasons : Nil
+
+  property saved : Bool
+
+  property score : Int32
+
+  property secure_media : Nil
+
+  property secure_media_embed : MediaEmbed
+
+  property selftext : String
+
+  property selftext_html : Nil
+
+  property spoiler : Bool
+
+  property stickied : Bool
+
+  property subreddit : String
+
+  property subreddit_id : String
+
+  property subreddit_name_prefixed : String
+
+  property subreddit_type : String
+
+  property suggested_sort : Nil
+
+  property thumbnail : String
+
+  property thumbnail_height : Int32
+
+  property thumbnail_width : Int32
+
+  property title : String
+
+  property ups : Int32
+
+  property url : String
+
+  property user_reports : Array(JSON::Any?)
+
+  property view_count : Nil
+
+  property visited : Bool
+
+  property whitelist_status : String
+end
+
+class MediaEmbed
+  include JSON::Serializable
+
+end
+
+class Preview
+  include JSON::Serializable
+
+  property enabled : Bool
+
+  property images : Array(Image)
+end
+
+class Image
+  include JSON::Serializable
+
+  property id : String
+
+  property resolutions : Array(Source)
+
+  property source : Source
+
+  property variants : Variants
+end
+
+class Source
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Variants
+  include JSON::Serializable
+
+  property gif : Gif?
+
+  property mp4 : Gif?
+end
+
+class Gif
+  include JSON::Serializable
+
+  property resolutions : Array(Source)
+
+  property source : Source
+end
diff --git a/head/crystal/test/inputs/json/samples/simple-object.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/simple-object.json/default/TopLevel.cr
new file mode 100644
index 0000000..5147fab
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/simple-object.json/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property date : Int32
+
+  property title : String
+
+  property validity : Bool
+end
diff --git a/head/crystal/test/inputs/json/samples/spotify-album.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/spotify-album.json/default/TopLevel.cr
new file mode 100644
index 0000000..c4f12e6
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/spotify-album.json/default/TopLevel.cr
@@ -0,0 +1,138 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property album_type : String
+
+  property artists : Array(Artist)
+
+  property available_markets : Array(String)
+
+  property copyrights : Array(Copyright)
+
+  property external_ids : ExternalIds
+
+  property external_urls : ExternalUrls
+
+  property genres : Array(JSON::Any?)
+
+  property href : String
+
+  property id : String
+
+  property images : Array(Image)
+
+  property name : String
+
+  property popularity : Int32
+
+  property release_date : String
+
+  property release_date_precision : String
+
+  @[JSON::Field(key: "type")]
+  property top_level_type : String
+
+  property tracks : Tracks
+
+  property uri : String
+end
+
+class Artist
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property artist_type : String
+
+  property external_urls : ExternalUrls
+
+  property href : String
+
+  property id : String
+
+  property name : String
+
+  property uri : String
+end
+
+class ExternalUrls
+  include JSON::Serializable
+
+  property spotify : String
+end
+
+class Copyright
+  include JSON::Serializable
+
+  @[JSON::Field(key: "type")]
+  property copyright_type : String
+
+  property text : String
+end
+
+class ExternalIds
+  include JSON::Serializable
+
+  property upc : String
+end
+
+class Image
+  include JSON::Serializable
+
+  property height : Int32
+
+  property url : String
+
+  property width : Int32
+end
+
+class Tracks
+  include JSON::Serializable
+
+  property href : String
+
+  property items : Array(Item)
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property previous : Nil
+
+  property total : Int32
+
+  @[JSON::Field(key: "next")]
+  property tracks_next : Nil
+end
+
+class Item
+  include JSON::Serializable
+
+  property artists : Array(Artist)
+
+  property available_markets : Array(String)
+
+  property disc_number : Int32
+
+  property duration_ms : Int32
+
+  property explicit : Bool
+
+  property external_urls : ExternalUrls
+
+  property href : String
+
+  property id : String
+
+  @[JSON::Field(key: "type")]
+  property item_type : String
+
+  property name : String
+
+  property preview_url : String
+
+  property track_number : Int32
+
+  property uri : String
+end
diff --git a/head/crystal/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.cr
new file mode 100644
index 0000000..c658019
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.cr
@@ -0,0 +1,29 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property data : Hash(String, Datum)
+
+  property description : Description
+end
+
+class Datum
+  include JSON::Serializable
+
+  property anomaly : String
+
+  property value : String
+end
+
+class Description
+  include JSON::Serializable
+
+  property base_period : String
+
+  property missing : Int32
+
+  property title : String
+
+  property units : String
+end
diff --git a/head/crystal/test/inputs/json/samples/us-senators.json/default/TopLevel.cr b/head/crystal/test/inputs/json/samples/us-senators.json/default/TopLevel.cr
new file mode 100644
index 0000000..691f349
--- /dev/null
+++ b/head/crystal/test/inputs/json/samples/us-senators.json/default/TopLevel.cr
@@ -0,0 +1,119 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property meta : Meta
+
+  property objects : Array(ObjectElement)
+end
+
+class Meta
+  include JSON::Serializable
+
+  property limit : Int32
+
+  property offset : Int32
+
+  property total_count : Int32
+end
+
+class ObjectElement
+  include JSON::Serializable
+
+  property caucus : String?
+
+  property congress_numbers : Array(Int32)
+
+  property current : Bool
+
+  property description : String
+
+  property district : Nil
+
+  property enddate : String
+
+  property extra : Extra
+
+  property leadership_title : String?
+
+  property party : String
+
+  property person : Person
+
+  property phone : String
+
+  property role_type : String
+
+  property role_type_label : String
+
+  property senator_class : String
+
+  property senator_class_label : String
+
+  property senator_rank : String
+
+  property senator_rank_label : String
+
+  property startdate : String
+
+  property state : String
+
+  property title : String
+
+  property title_long : String
+
+  property website : String
+end
+
+class Extra
+  include JSON::Serializable
+
+  property address : String
+
+  property contact_form : String
+
+  property fax : String?
+
+  property office : String
+
+  property rss_url : String?
+end
+
+class Person
+  include JSON::Serializable
+
+  property bioguideid : String
+
+  property birthday : String
+
+  property cspanid : Int32
+
+  property firstname : String
+
+  property gender : String
+
+  property gender_label : String
+
+  property lastname : String
+
+  property link : String
+
+  property middlename : String
+
+  property name : String
+
+  property namemod : String
+
+  property nickname : String
+
+  property osid : String
+
+  property pvsid : String
+
+  property sortname : String
+
+  property twitterid : String?
+
+  property youtubeid : String?
+end
diff --git a/head/dart/test/inputs/json/priority/bug427.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/bug427.json/default/TopLevel.dart
new file mode 100644
index 0000000..30d3770
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/bug427.json/default/TopLevel.dart
@@ -0,0 +1,2361 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<TopLevelChild> children;
+    final GetSignatureFlags flags;
+    final List<Group> groups;
+    final int id;
+    final int kind;
+    final String name;
+
+    TopLevel({
+        required this.children,
+        required this.flags,
+        required this.groups,
+        required this.id,
+        required this.kind,
+        required this.name,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        children: List<TopLevelChild>.from(json["children"].map((x) => TopLevelChild.fromJson(x))),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: List<Group>.from(json["groups"].map((x) => Group.fromJson(x))),
+        id: json["id"],
+        kind: json["kind"],
+        name: json["name"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": List<dynamic>.from(children.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": List<dynamic>.from(groups.map((x) => x.toJson())),
+        "id": id,
+        "kind": kind,
+        "name": name,
+    };
+}
+
+class TopLevelChild {
+    final List<PurpleChild> children;
+    final IndecentComment? comment;
+    final PurpleFlags flags;
+    final List<Group> groups;
+    final int id;
+    final int kind;
+    final TentacledKindString kindString;
+    final String name;
+    final String originalName;
+    final List<Source> sources;
+
+    TopLevelChild({
+        required this.children,
+        this.comment,
+        required this.flags,
+        required this.groups,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.originalName,
+        required this.sources,
+    });
+
+    factory TopLevelChild.fromJson(Map<String, dynamic> json) => TopLevelChild(
+        children: List<PurpleChild>.from(json["children"].map((x) => PurpleChild.fromJson(x))),
+        comment: json["comment"] == null ? null : IndecentComment.fromJson(json["comment"]),
+        flags: PurpleFlags.fromJson(json["flags"]),
+        groups: List<Group>.from(json["groups"].map((x) => Group.fromJson(x))),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: tentacledKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        originalName: json["originalName"],
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": List<dynamic>.from(children.map((x) => x.toJson())),
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "groups": List<dynamic>.from(groups.map((x) => x.toJson())),
+        "id": id,
+        "kind": kind,
+        "kindString": tentacledKindStringValues.reverse[kindString],
+        "name": name,
+        "originalName": originalName,
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+    };
+}
+
+class PurpleChild {
+    final List<FluffyChild>? children;
+    final StickyComment? comment;
+    final String? defaultValue;
+    final List<ExtendedBy>? extendedBy;
+    final List<ExtendedBy>? extendedTypes;
+    final IndecentFlags flags;
+    final List<Group>? groups;
+    final int id;
+    final List<ExtendedBy>? implementedBy;
+    final List<ExtendedBy>? implementedTypes;
+    final int kind;
+    final FluffyKindString kindString;
+    final String name;
+    final List<StickySignature>? signatures;
+    final List<Source> sources;
+    final MagentaType? type;
+    final List<TypeParameter>? typeParameter;
+
+    PurpleChild({
+        this.children,
+        this.comment,
+        this.defaultValue,
+        this.extendedBy,
+        this.extendedTypes,
+        required this.flags,
+        this.groups,
+        required this.id,
+        this.implementedBy,
+        this.implementedTypes,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.signatures,
+        required this.sources,
+        this.type,
+        this.typeParameter,
+    });
+
+    factory PurpleChild.fromJson(Map<String, dynamic> json) => PurpleChild(
+        children: json["children"] == null ? null : List<FluffyChild>.from(json["children"]!.map((x) => FluffyChild.fromJson(x))),
+        comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]),
+        defaultValue: json["defaultValue"],
+        extendedBy: json["extendedBy"] == null ? null : List<ExtendedBy>.from(json["extendedBy"]!.map((x) => ExtendedBy.fromJson(x))),
+        extendedTypes: json["extendedTypes"] == null ? null : List<ExtendedBy>.from(json["extendedTypes"]!.map((x) => ExtendedBy.fromJson(x))),
+        flags: IndecentFlags.fromJson(json["flags"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        implementedBy: json["implementedBy"] == null ? null : List<ExtendedBy>.from(json["implementedBy"]!.map((x) => ExtendedBy.fromJson(x))),
+        implementedTypes: json["implementedTypes"] == null ? null : List<ExtendedBy>.from(json["implementedTypes"]!.map((x) => ExtendedBy.fromJson(x))),
+        kind: json["kind"],
+        kindString: fluffyKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        signatures: json["signatures"] == null ? null : List<StickySignature>.from(json["signatures"]!.map((x) => StickySignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: json["type"] == null ? null : MagentaType.fromJson(json["type"]),
+        typeParameter: json["typeParameter"] == null ? null : List<TypeParameter>.from(json["typeParameter"]!.map((x) => TypeParameter.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "comment": comment?.toJson(),
+        "defaultValue": defaultValue,
+        "extendedBy": extendedBy == null ? null : List<dynamic>.from(extendedBy!.map((x) => x.toJson())),
+        "extendedTypes": extendedTypes == null ? null : List<dynamic>.from(extendedTypes!.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "implementedBy": implementedBy == null ? null : List<dynamic>.from(implementedBy!.map((x) => x.toJson())),
+        "implementedTypes": implementedTypes == null ? null : List<dynamic>.from(implementedTypes!.map((x) => x.toJson())),
+        "kind": kind,
+        "kindString": fluffyKindStringValues.reverse[kindString],
+        "name": name,
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type?.toJson(),
+        "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
+    };
+}
+
+class FluffyChild {
+    final List<TentacledChild>? children;
+    final StickyComment? comment;
+    final String? defaultValue;
+    final StickyFlags flags;
+    final GetSignature? getSignature;
+    final List<Group>? groups;
+    final int id;
+    final ExtendedBy? implementationOf;
+    final ExtendedBy? inheritedFrom;
+    final int kind;
+    final PurpleKindString kindString;
+    final String name;
+    final ExtendedBy? overwrites;
+    final GetSignature? setSignature;
+    final List<FluffySignature>? signatures;
+    final List<Source> sources;
+    final IndigoType? type;
+
+    FluffyChild({
+        this.children,
+        this.comment,
+        this.defaultValue,
+        required this.flags,
+        this.getSignature,
+        this.groups,
+        required this.id,
+        this.implementationOf,
+        this.inheritedFrom,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.overwrites,
+        this.setSignature,
+        this.signatures,
+        required this.sources,
+        this.type,
+    });
+
+    factory FluffyChild.fromJson(Map<String, dynamic> json) => FluffyChild(
+        children: json["children"] == null ? null : List<TentacledChild>.from(json["children"]!.map((x) => TentacledChild.fromJson(x))),
+        comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]),
+        defaultValue: json["defaultValue"],
+        flags: StickyFlags.fromJson(json["flags"]),
+        getSignature: json["getSignature"] == null ? null : GetSignature.fromJson(json["getSignature"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        implementationOf: json["implementationOf"] == null ? null : ExtendedBy.fromJson(json["implementationOf"]),
+        inheritedFrom: json["inheritedFrom"] == null ? null : ExtendedBy.fromJson(json["inheritedFrom"]),
+        kind: json["kind"],
+        kindString: purpleKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        overwrites: json["overwrites"] == null ? null : ExtendedBy.fromJson(json["overwrites"]),
+        setSignature: json["setSignature"] == null ? null : GetSignature.fromJson(json["setSignature"]),
+        signatures: json["signatures"] == null ? null : List<FluffySignature>.from(json["signatures"]!.map((x) => FluffySignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: json["type"] == null ? null : IndigoType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "comment": comment?.toJson(),
+        "defaultValue": defaultValue,
+        "flags": flags.toJson(),
+        "getSignature": getSignature?.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "implementationOf": implementationOf?.toJson(),
+        "inheritedFrom": inheritedFrom?.toJson(),
+        "kind": kind,
+        "kindString": purpleKindStringValues.reverse[kindString],
+        "name": name,
+        "overwrites": overwrites?.toJson(),
+        "setSignature": setSignature?.toJson(),
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type?.toJson(),
+    };
+}
+
+class TentacledChild {
+    final PurpleComment? comment;
+    final String? defaultValue;
+    final PurpleFlags flags;
+    final int id;
+    final int kind;
+    final PurpleKindString kindString;
+    final String name;
+    final List<PurpleSignature>? signatures;
+    final List<Source> sources;
+    final TypeElement? type;
+
+    TentacledChild({
+        this.comment,
+        this.defaultValue,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.signatures,
+        required this.sources,
+        this.type,
+    });
+
+    factory TentacledChild.fromJson(Map<String, dynamic> json) => TentacledChild(
+        comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]),
+        defaultValue: json["defaultValue"],
+        flags: PurpleFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: purpleKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        signatures: json["signatures"] == null ? null : List<PurpleSignature>.from(json["signatures"]!.map((x) => PurpleSignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: json["type"] == null ? null : TypeElement.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "defaultValue": defaultValue,
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": purpleKindStringValues.reverse[kindString],
+        "name": name,
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type?.toJson(),
+    };
+}
+
+class PurpleComment {
+    final String shortText;
+
+    PurpleComment({
+        required this.shortText,
+    });
+
+    factory PurpleComment.fromJson(Map<String, dynamic> json) => PurpleComment(
+        shortText: json["shortText"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "shortText": shortText,
+    };
+}
+
+class PurpleFlags {
+    final bool? isExported;
+
+    PurpleFlags({
+        this.isExported,
+    });
+
+    factory PurpleFlags.fromJson(Map<String, dynamic> json) => PurpleFlags(
+        isExported: json["isExported"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "isExported": isExported,
+    };
+}
+
+enum PurpleKindString {
+    VARIABLE,
+    FUNCTION,
+    PROPERTY,
+    METHOD,
+    CONSTRUCTOR,
+    ACCESSOR,
+    ENUMERATION_MEMBER,
+    MODULE,
+    OBJECT_LITERAL
+}
+
+final purpleKindStringValues = EnumValues({
+    "Variable": PurpleKindString.VARIABLE,
+    "Function": PurpleKindString.FUNCTION,
+    "Property": PurpleKindString.PROPERTY,
+    "Method": PurpleKindString.METHOD,
+    "Constructor": PurpleKindString.CONSTRUCTOR,
+    "Accessor": PurpleKindString.ACCESSOR,
+    "Enumeration member": PurpleKindString.ENUMERATION_MEMBER,
+    "Module": PurpleKindString.MODULE,
+    "Object literal": PurpleKindString.OBJECT_LITERAL
+});
+
+class PurpleSignature {
+    final PurpleComment? comment;
+    final GetSignatureFlags flags;
+    final int id;
+    final int kind;
+    final SignatureKindString kindString;
+    final String name;
+    final List<GetSignature> parameters;
+    final TentacledType type;
+
+    PurpleSignature({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.parameters,
+        required this.type,
+    });
+
+    factory PurpleSignature.fromJson(Map<String, dynamic> json) => PurpleSignature(
+        comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: signatureKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        parameters: List<GetSignature>.from(json["parameters"].map((x) => GetSignature.fromJson(x))),
+        type: TentacledType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": signatureKindStringValues.reverse[kindString],
+        "name": name,
+        "parameters": List<dynamic>.from(parameters.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class GetSignatureFlags {
+    GetSignatureFlags();
+
+    factory GetSignatureFlags.fromJson(Map<String, dynamic> json) => GetSignatureFlags(
+    );
+
+    Map<String, dynamic> toJson() => {
+    };
+}
+
+enum SignatureKindString {
+    CALL_SIGNATURE,
+    CONSTRUCTOR_SIGNATURE
+}
+
+final signatureKindStringValues = EnumValues({
+    "Call signature": SignatureKindString.CALL_SIGNATURE,
+    "Constructor signature": SignatureKindString.CONSTRUCTOR_SIGNATURE
+});
+
+class GetSignatureType {
+    final GetSignature? declaration;
+    final ElementType? elementType;
+    final Name? name;
+    final TypeEnum type;
+
+    GetSignatureType({
+        this.declaration,
+        this.elementType,
+        this.name,
+        required this.type,
+    });
+
+    factory GetSignatureType.fromJson(Map<String, dynamic> json) => GetSignatureType(
+        declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
+        elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "elementType": elementType?.toJson(),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+class IndexSignatureElement {
+    final GetSignatureFlags flags;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<GetSignature>? parameters;
+    final PurpleType type;
+
+    IndexSignatureElement({
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.parameters,
+        required this.type,
+    });
+
+    factory IndexSignatureElement.fromJson(Map<String, dynamic> json) => IndexSignatureElement(
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        parameters: json["parameters"] == null ? null : List<GetSignature>.from(json["parameters"]!.map((x) => GetSignature.fromJson(x))),
+        type: PurpleType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class PurpleType {
+    final GetSignature? declaration;
+    final Name? name;
+    final TypeEnum type;
+
+    PurpleType({
+        this.declaration,
+        this.name,
+        required this.type,
+    });
+
+    factory PurpleType.fromJson(Map<String, dynamic> json) => PurpleType(
+        declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+class GetSignatureChild {
+    final FluffyComment? comment;
+    final FluffyFlags flags;
+    final int id;
+    final int kind;
+    final PurpleKindString kindString;
+    final String name;
+    final List<Source> sources;
+    final PurpleType type;
+
+    GetSignatureChild({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.sources,
+        required this.type,
+    });
+
+    factory GetSignatureChild.fromJson(Map<String, dynamic> json) => GetSignatureChild(
+        comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]),
+        flags: FluffyFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: purpleKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: PurpleType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": purpleKindStringValues.reverse[kindString],
+        "name": name,
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class GetSignature {
+    final List<GetSignatureChild>? children;
+    final GetSignatureComment? comment;
+    final String? defaultValue;
+    final GetSignatureFlags flags;
+    final List<Group>? groups;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<GetSignatureParameter>? parameters;
+    final List<IndexSignatureElement>? signatures;
+    final List<Source>? sources;
+    final GetSignatureType? type;
+    final List<GetSignature>? typeParameter;
+
+    GetSignature({
+        this.children,
+        this.comment,
+        this.defaultValue,
+        required this.flags,
+        this.groups,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.parameters,
+        this.signatures,
+        this.sources,
+        this.type,
+        this.typeParameter,
+    });
+
+    factory GetSignature.fromJson(Map<String, dynamic> json) => GetSignature(
+        children: json["children"] == null ? null : List<GetSignatureChild>.from(json["children"]!.map((x) => GetSignatureChild.fromJson(x))),
+        comment: json["comment"] == null ? null : GetSignatureComment.fromJson(json["comment"]),
+        defaultValue: json["defaultValue"],
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        parameters: json["parameters"] == null ? null : List<GetSignatureParameter>.from(json["parameters"]!.map((x) => GetSignatureParameter.fromJson(x))),
+        signatures: json["signatures"] == null ? null : List<IndexSignatureElement>.from(json["signatures"]!.map((x) => IndexSignatureElement.fromJson(x))),
+        sources: json["sources"] == null ? null : List<Source>.from(json["sources"]!.map((x) => Source.fromJson(x))),
+        type: json["type"] == null ? null : GetSignatureType.fromJson(json["type"]),
+        typeParameter: json["typeParameter"] == null ? null : List<GetSignature>.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "comment": comment?.toJson(),
+        "defaultValue": defaultValue,
+        "flags": flags.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": sources == null ? null : List<dynamic>.from(sources!.map((x) => x.toJson())),
+        "type": type?.toJson(),
+        "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
+    };
+}
+
+class ElementType {
+    final Name name;
+    final TypeEnum type;
+
+    ElementType({
+        required this.name,
+        required this.type,
+    });
+
+    factory ElementType.fromJson(Map<String, dynamic> json) => ElementType(
+        name: nameValues.map[json["name"]]!,
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+enum Name {
+    STRING,
+    NUMBER,
+    VOID,
+    T,
+    BOOLEAN,
+    BASE_CLASS,
+    ANY,
+    ARRAY,
+    MY_NUMBER
+}
+
+final nameValues = EnumValues({
+    "string": Name.STRING,
+    "number": Name.NUMBER,
+    "void": Name.VOID,
+    "T": Name.T,
+    "boolean": Name.BOOLEAN,
+    "BaseClass": Name.BASE_CLASS,
+    "any": Name.ANY,
+    "Array": Name.ARRAY,
+    "MyNumber": Name.MY_NUMBER
+});
+
+enum TypeEnum {
+    INTRINSIC,
+    REFLECTION,
+    ARRAY,
+    REFERENCE,
+    TYPE_PARAMETER,
+    TUPLE,
+    UNION,
+    STRING_LITERAL
+}
+
+final typeEnumValues = EnumValues({
+    "intrinsic": TypeEnum.INTRINSIC,
+    "reflection": TypeEnum.REFLECTION,
+    "array": TypeEnum.ARRAY,
+    "reference": TypeEnum.REFERENCE,
+    "typeParameter": TypeEnum.TYPE_PARAMETER,
+    "tuple": TypeEnum.TUPLE,
+    "union": TypeEnum.UNION,
+    "stringLiteral": TypeEnum.STRING_LITERAL
+});
+
+class FluffyComment {
+    final String text;
+
+    FluffyComment({
+        required this.text,
+    });
+
+    factory FluffyComment.fromJson(Map<String, dynamic> json) => FluffyComment(
+        text: json["text"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "text": text,
+    };
+}
+
+class FluffyFlags {
+    final bool? isOptional;
+
+    FluffyFlags({
+        this.isOptional,
+    });
+
+    factory FluffyFlags.fromJson(Map<String, dynamic> json) => FluffyFlags(
+        isOptional: json["isOptional"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "isOptional": isOptional,
+    };
+}
+
+class Source {
+    final int character;
+    final FileName fileName;
+    final int line;
+
+    Source({
+        required this.character,
+        required this.fileName,
+        required this.line,
+    });
+
+    factory Source.fromJson(Map<String, dynamic> json) => Source(
+        character: json["character"],
+        fileName: fileNameValues.map[json["fileName"]]!,
+        line: json["line"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "character": character,
+        "fileName": fileNameValues.reverse[fileName],
+        "line": line,
+    };
+}
+
+enum FileName {
+    MODULES_TS,
+    CLASSES_TS,
+    FLATTENED_TS,
+    ACCESS_TS,
+    DEFAULT_EXPORT_TS,
+    ENUMERATIONS_TS,
+    FUNCTIONS_TS,
+    GENERICS_TS,
+    SINGLE_EXPORT_TS,
+    TYPESCRIPT_13_TS,
+    TYPESCRIPT_14_TS,
+    TYPESCRIPT_15_TS,
+    VARIABLES_TS
+}
+
+final fileNameValues = EnumValues({
+    "modules.ts": FileName.MODULES_TS,
+    "classes.ts": FileName.CLASSES_TS,
+    "flattened.ts": FileName.FLATTENED_TS,
+    "access.ts": FileName.ACCESS_TS,
+    "default-export.ts": FileName.DEFAULT_EXPORT_TS,
+    "enumerations.ts": FileName.ENUMERATIONS_TS,
+    "functions.ts": FileName.FUNCTIONS_TS,
+    "generics.ts": FileName.GENERICS_TS,
+    "single-export.ts": FileName.SINGLE_EXPORT_TS,
+    "typescript-1.3.ts": FileName.TYPESCRIPT_13_TS,
+    "typescript-1.4.ts": FileName.TYPESCRIPT_14_TS,
+    "typescript-1.5.ts": FileName.TYPESCRIPT_15_TS,
+    "variables.ts": FileName.VARIABLES_TS
+});
+
+class GetSignatureComment {
+    final String? returns;
+    final String? shortText;
+    final String? text;
+
+    GetSignatureComment({
+        this.returns,
+        this.shortText,
+        this.text,
+    });
+
+    factory GetSignatureComment.fromJson(Map<String, dynamic> json) => GetSignatureComment(
+        returns: json["returns"],
+        shortText: json["shortText"],
+        text: json["text"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "returns": returns,
+        "shortText": shortText,
+        "text": text,
+    };
+}
+
+class Group {
+    final List<int> children;
+    final int kind;
+    final String title;
+
+    Group({
+        required this.children,
+        required this.kind,
+        required this.title,
+    });
+
+    factory Group.fromJson(Map<String, dynamic> json) => Group(
+        children: List<int>.from(json["children"].map((x) => x)),
+        kind: json["kind"],
+        title: json["title"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": List<dynamic>.from(children.map((x) => x)),
+        "kind": kind,
+        "title": title,
+    };
+}
+
+class GetSignatureParameter {
+    final TentacledComment? comment;
+    final TentacledFlags flags;
+    final int id;
+    final int kind;
+    final ParameterKindString kindString;
+    final String name;
+    final FluffyType type;
+
+    GetSignatureParameter({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.type,
+    });
+
+    factory GetSignatureParameter.fromJson(Map<String, dynamic> json) => GetSignatureParameter(
+        comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]),
+        flags: TentacledFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: parameterKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        type: FluffyType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": parameterKindStringValues.reverse[kindString],
+        "name": name,
+        "type": type.toJson(),
+    };
+}
+
+class TentacledComment {
+    final String? shortText;
+    final String? text;
+
+    TentacledComment({
+        this.shortText,
+        this.text,
+    });
+
+    factory TentacledComment.fromJson(Map<String, dynamic> json) => TentacledComment(
+        shortText: json["shortText"],
+        text: json["text"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "shortText": shortText,
+        "text": text,
+    };
+}
+
+class TentacledFlags {
+    final bool? isOptional;
+    final bool? isRest;
+
+    TentacledFlags({
+        this.isOptional,
+        this.isRest,
+    });
+
+    factory TentacledFlags.fromJson(Map<String, dynamic> json) => TentacledFlags(
+        isOptional: json["isOptional"],
+        isRest: json["isRest"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "isOptional": isOptional,
+        "isRest": isRest,
+    };
+}
+
+enum ParameterKindString {
+    PARAMETER
+}
+
+final parameterKindStringValues = EnumValues({
+    "Parameter": ParameterKindString.PARAMETER
+});
+
+class FluffyType {
+    final ElementType? elementType;
+    final Name? name;
+    final TypeEnum type;
+    final List<ElementType>? typeArguments;
+
+    FluffyType({
+        this.elementType,
+        this.name,
+        required this.type,
+        this.typeArguments,
+    });
+
+    factory FluffyType.fromJson(Map<String, dynamic> json) => FluffyType(
+        elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "elementType": elementType?.toJson(),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+    };
+}
+
+class TentacledType {
+    final PurpleDeclaration? declaration;
+    final Name? name;
+    final TypeEnum type;
+
+    TentacledType({
+        this.declaration,
+        this.name,
+        required this.type,
+    });
+
+    factory TentacledType.fromJson(Map<String, dynamic> json) => TentacledType(
+        declaration: json["declaration"] == null ? null : PurpleDeclaration.fromJson(json["declaration"]),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+class PurpleDeclaration {
+    final List<GetSignature> children;
+    final GetSignatureFlags flags;
+    final List<Group> groups;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+
+    PurpleDeclaration({
+        required this.children,
+        required this.flags,
+        required this.groups,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+    });
+
+    factory PurpleDeclaration.fromJson(Map<String, dynamic> json) => PurpleDeclaration(
+        children: List<GetSignature>.from(json["children"].map((x) => GetSignature.fromJson(x))),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: List<Group>.from(json["groups"].map((x) => Group.fromJson(x))),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": List<dynamic>.from(children.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": List<dynamic>.from(groups.map((x) => x.toJson())),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+    };
+}
+
+class TypeElement {
+    final GetSignature? declaration;
+    final ElementType? elementType;
+    final Name? name;
+    final TypeEnum type;
+    final List<ElementType>? typeArguments;
+
+    TypeElement({
+        this.declaration,
+        this.elementType,
+        this.name,
+        required this.type,
+        this.typeArguments,
+    });
+
+    factory TypeElement.fromJson(Map<String, dynamic> json) => TypeElement(
+        declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
+        elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "elementType": elementType?.toJson(),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+    };
+}
+
+class StickyComment {
+    final String? returns;
+    final String? shortText;
+    final List<Tag>? tags;
+    final String? text;
+
+    StickyComment({
+        this.returns,
+        this.shortText,
+        this.tags,
+        this.text,
+    });
+
+    factory StickyComment.fromJson(Map<String, dynamic> json) => StickyComment(
+        returns: json["returns"],
+        shortText: json["shortText"],
+        tags: json["tags"] == null ? null : List<Tag>.from(json["tags"]!.map((x) => Tag.fromJson(x))),
+        text: json["text"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "returns": returns,
+        "shortText": shortText,
+        "tags": tags == null ? null : List<dynamic>.from(tags!.map((x) => x.toJson())),
+        "text": text,
+    };
+}
+
+class Tag {
+    final String tag;
+    final String text;
+
+    Tag({
+        required this.tag,
+        required this.text,
+    });
+
+    factory Tag.fromJson(Map<String, dynamic> json) => Tag(
+        tag: json["tag"],
+        text: json["text"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "tag": tag,
+        "text": text,
+    };
+}
+
+class StickyFlags {
+    final bool? isAbstract;
+    final bool? isConstructorProperty;
+    final bool? isExported;
+    final bool? isPrivate;
+    final bool? isProtected;
+    final bool? isPublic;
+    final bool? isStatic;
+
+    StickyFlags({
+        this.isAbstract,
+        this.isConstructorProperty,
+        this.isExported,
+        this.isPrivate,
+        this.isProtected,
+        this.isPublic,
+        this.isStatic,
+    });
+
+    factory StickyFlags.fromJson(Map<String, dynamic> json) => StickyFlags(
+        isAbstract: json["isAbstract"],
+        isConstructorProperty: json["isConstructorProperty"],
+        isExported: json["isExported"],
+        isPrivate: json["isPrivate"],
+        isProtected: json["isProtected"],
+        isPublic: json["isPublic"],
+        isStatic: json["isStatic"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "isAbstract": isAbstract,
+        "isConstructorProperty": isConstructorProperty,
+        "isExported": isExported,
+        "isPrivate": isPrivate,
+        "isProtected": isProtected,
+        "isPublic": isPublic,
+        "isStatic": isStatic,
+    };
+}
+
+class ExtendedBy {
+    final ExtendedBy? constraint;
+    final int? id;
+    final String name;
+    final TypeEnum type;
+    final List<ExtendedBy>? typeArguments;
+
+    ExtendedBy({
+        this.constraint,
+        this.id,
+        required this.name,
+        required this.type,
+        this.typeArguments,
+    });
+
+    factory ExtendedBy.fromJson(Map<String, dynamic> json) => ExtendedBy(
+        constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]),
+        id: json["id"],
+        name: json["name"],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<ExtendedBy>.from(json["typeArguments"]!.map((x) => ExtendedBy.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "constraint": constraint?.toJson(),
+        "id": id,
+        "name": name,
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+    };
+}
+
+class FluffySignature {
+    final StickyComment? comment;
+    final IndigoFlags flags;
+    final int id;
+    final ExtendedBy? implementationOf;
+    final ExtendedBy? inheritedFrom;
+    final int kind;
+    final SignatureKindString kindString;
+    final String name;
+    final ExtendedBy? overwrites;
+    final List<PurpleParameter>? parameters;
+    final ExtendedBy type;
+    final List<GetSignature>? typeParameter;
+
+    FluffySignature({
+        this.comment,
+        required this.flags,
+        required this.id,
+        this.implementationOf,
+        this.inheritedFrom,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.overwrites,
+        this.parameters,
+        required this.type,
+        this.typeParameter,
+    });
+
+    factory FluffySignature.fromJson(Map<String, dynamic> json) => FluffySignature(
+        comment: json["comment"] == null ? null : StickyComment.fromJson(json["comment"]),
+        flags: IndigoFlags.fromJson(json["flags"]),
+        id: json["id"],
+        implementationOf: json["implementationOf"] == null ? null : ExtendedBy.fromJson(json["implementationOf"]),
+        inheritedFrom: json["inheritedFrom"] == null ? null : ExtendedBy.fromJson(json["inheritedFrom"]),
+        kind: json["kind"],
+        kindString: signatureKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        overwrites: json["overwrites"] == null ? null : ExtendedBy.fromJson(json["overwrites"]),
+        parameters: json["parameters"] == null ? null : List<PurpleParameter>.from(json["parameters"]!.map((x) => PurpleParameter.fromJson(x))),
+        type: ExtendedBy.fromJson(json["type"]),
+        typeParameter: json["typeParameter"] == null ? null : List<GetSignature>.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "implementationOf": implementationOf?.toJson(),
+        "inheritedFrom": inheritedFrom?.toJson(),
+        "kind": kind,
+        "kindString": signatureKindStringValues.reverse[kindString],
+        "name": name,
+        "overwrites": overwrites?.toJson(),
+        "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
+        "type": type.toJson(),
+        "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
+    };
+}
+
+class IndigoFlags {
+    final bool? isPrivate;
+    final bool? isProtected;
+
+    IndigoFlags({
+        this.isPrivate,
+        this.isProtected,
+    });
+
+    factory IndigoFlags.fromJson(Map<String, dynamic> json) => IndigoFlags(
+        isPrivate: json["isPrivate"],
+        isProtected: json["isProtected"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "isPrivate": isPrivate,
+        "isProtected": isProtected,
+    };
+}
+
+class PurpleParameter {
+    final TentacledComment? comment;
+    final GetSignatureFlags flags;
+    final int id;
+    final int kind;
+    final ParameterKindString kindString;
+    final String name;
+    final StickyType type;
+
+    PurpleParameter({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.type,
+    });
+
+    factory PurpleParameter.fromJson(Map<String, dynamic> json) => PurpleParameter(
+        comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: parameterKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        type: StickyType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": parameterKindStringValues.reverse[kindString],
+        "name": name,
+        "type": type.toJson(),
+    };
+}
+
+class StickyType {
+    final ExtendedBy? constraint;
+    final GetSignature? declaration;
+    final ElementType? elementType;
+    final List<ExtendedBy>? elements;
+    final int? id;
+    final String? name;
+    final TypeEnum type;
+    final List<ElementType>? typeArguments;
+
+    StickyType({
+        this.constraint,
+        this.declaration,
+        this.elementType,
+        this.elements,
+        this.id,
+        this.name,
+        required this.type,
+        this.typeArguments,
+    });
+
+    factory StickyType.fromJson(Map<String, dynamic> json) => StickyType(
+        constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]),
+        declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
+        elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
+        elements: json["elements"] == null ? null : List<ExtendedBy>.from(json["elements"]!.map((x) => ExtendedBy.fromJson(x))),
+        id: json["id"],
+        name: json["name"],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "constraint": constraint?.toJson(),
+        "declaration": declaration?.toJson(),
+        "elementType": elementType?.toJson(),
+        "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
+        "id": id,
+        "name": name,
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+    };
+}
+
+class IndigoType {
+    final ExtendedBy? constraint;
+    final FluffyDeclaration? declaration;
+    final ExtendedBy? elementType;
+    final List<ElementType>? elements;
+    final int? id;
+    final String? name;
+    final TypeEnum type;
+    final List<PurpleTypeArgument>? typeArguments;
+    final List<TypeElement>? types;
+
+    IndigoType({
+        this.constraint,
+        this.declaration,
+        this.elementType,
+        this.elements,
+        this.id,
+        this.name,
+        required this.type,
+        this.typeArguments,
+        this.types,
+    });
+
+    factory IndigoType.fromJson(Map<String, dynamic> json) => IndigoType(
+        constraint: json["constraint"] == null ? null : ExtendedBy.fromJson(json["constraint"]),
+        declaration: json["declaration"] == null ? null : FluffyDeclaration.fromJson(json["declaration"]),
+        elementType: json["elementType"] == null ? null : ExtendedBy.fromJson(json["elementType"]),
+        elements: json["elements"] == null ? null : List<ElementType>.from(json["elements"]!.map((x) => ElementType.fromJson(x))),
+        id: json["id"],
+        name: json["name"],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<PurpleTypeArgument>.from(json["typeArguments"]!.map((x) => PurpleTypeArgument.fromJson(x))),
+        types: json["types"] == null ? null : List<TypeElement>.from(json["types"]!.map((x) => TypeElement.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "constraint": constraint?.toJson(),
+        "declaration": declaration?.toJson(),
+        "elementType": elementType?.toJson(),
+        "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
+        "id": id,
+        "name": name,
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+        "types": types == null ? null : List<dynamic>.from(types!.map((x) => x.toJson())),
+    };
+}
+
+class FluffyDeclaration {
+    final List<StickyChild>? children;
+    final GetSignatureFlags flags;
+    final List<Group>? groups;
+    final int id;
+    final IndexSignature? indexSignature;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<TentacledSignature>? signatures;
+    final List<Source> sources;
+
+    FluffyDeclaration({
+        this.children,
+        required this.flags,
+        this.groups,
+        required this.id,
+        this.indexSignature,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.signatures,
+        required this.sources,
+    });
+
+    factory FluffyDeclaration.fromJson(Map<String, dynamic> json) => FluffyDeclaration(
+        children: json["children"] == null ? null : List<StickyChild>.from(json["children"]!.map((x) => StickyChild.fromJson(x))),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        indexSignature: json["indexSignature"] == null ? null : IndexSignature.fromJson(json["indexSignature"]),
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        signatures: json["signatures"] == null ? null : List<TentacledSignature>.from(json["signatures"]!.map((x) => TentacledSignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "indexSignature": indexSignature?.toJson(),
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+    };
+}
+
+class StickyChild {
+    final FluffyComment? comment;
+    final FluffyFlags flags;
+    final int id;
+    final int kind;
+    final PurpleKindString kindString;
+    final String name;
+    final List<Source> sources;
+    final IndecentType type;
+
+    StickyChild({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.sources,
+        required this.type,
+    });
+
+    factory StickyChild.fromJson(Map<String, dynamic> json) => StickyChild(
+        comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]),
+        flags: FluffyFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: purpleKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: IndecentType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": purpleKindStringValues.reverse[kindString],
+        "name": name,
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class IndecentType {
+    final GetSignature? declaration;
+    final List<ElementType>? elements;
+    final Name? name;
+    final TypeEnum type;
+
+    IndecentType({
+        this.declaration,
+        this.elements,
+        this.name,
+        required this.type,
+    });
+
+    factory IndecentType.fromJson(Map<String, dynamic> json) => IndecentType(
+        declaration: json["declaration"] == null ? null : GetSignature.fromJson(json["declaration"]),
+        elements: json["elements"] == null ? null : List<ElementType>.from(json["elements"]!.map((x) => ElementType.fromJson(x))),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+class IndexSignature {
+    final GetSignatureFlags flags;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<GetSignature> parameters;
+    final HilariousType type;
+
+    IndexSignature({
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.parameters,
+        required this.type,
+    });
+
+    factory IndexSignature.fromJson(Map<String, dynamic> json) => IndexSignature(
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        parameters: List<GetSignature>.from(json["parameters"].map((x) => GetSignature.fromJson(x))),
+        type: HilariousType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "parameters": List<dynamic>.from(parameters.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class HilariousType {
+    final GetSignature declaration;
+    final TypeEnum type;
+
+    HilariousType({
+        required this.declaration,
+        required this.type,
+    });
+
+    factory HilariousType.fromJson(Map<String, dynamic> json) => HilariousType(
+        declaration: GetSignature.fromJson(json["declaration"]),
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration.toJson(),
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+class TentacledSignature {
+    final IndigoComment? comment;
+    final GetSignatureFlags flags;
+    final int id;
+    final int kind;
+    final SignatureKindString kindString;
+    final String name;
+    final List<FluffyParameter>? parameters;
+    final ExtendedBy type;
+
+    TentacledSignature({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.parameters,
+        required this.type,
+    });
+
+    factory TentacledSignature.fromJson(Map<String, dynamic> json) => TentacledSignature(
+        comment: json["comment"] == null ? null : IndigoComment.fromJson(json["comment"]),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: signatureKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        parameters: json["parameters"] == null ? null : List<FluffyParameter>.from(json["parameters"]!.map((x) => FluffyParameter.fromJson(x))),
+        type: ExtendedBy.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": signatureKindStringValues.reverse[kindString],
+        "name": name,
+        "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class IndigoComment {
+    final String returns;
+    final String shortText;
+
+    IndigoComment({
+        required this.returns,
+        required this.shortText,
+    });
+
+    factory IndigoComment.fromJson(Map<String, dynamic> json) => IndigoComment(
+        returns: json["returns"],
+        shortText: json["shortText"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "returns": returns,
+        "shortText": shortText,
+    };
+}
+
+class FluffyParameter {
+    final FluffyComment? comment;
+    final FluffyFlags flags;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<Source>? sources;
+    final ElementType type;
+
+    FluffyParameter({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.sources,
+        required this.type,
+    });
+
+    factory FluffyParameter.fromJson(Map<String, dynamic> json) => FluffyParameter(
+        comment: json["comment"] == null ? null : FluffyComment.fromJson(json["comment"]),
+        flags: FluffyFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        sources: json["sources"] == null ? null : List<Source>.from(json["sources"]!.map((x) => Source.fromJson(x))),
+        type: ElementType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "sources": sources == null ? null : List<dynamic>.from(sources!.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class PurpleTypeArgument {
+    final ElementType target;
+    final String type;
+    final String typeArgumentOperator;
+
+    PurpleTypeArgument({
+        required this.target,
+        required this.type,
+        required this.typeArgumentOperator,
+    });
+
+    factory PurpleTypeArgument.fromJson(Map<String, dynamic> json) => PurpleTypeArgument(
+        target: ElementType.fromJson(json["target"]),
+        type: json["type"],
+        typeArgumentOperator: json["operator"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "target": target.toJson(),
+        "type": type,
+        "operator": typeArgumentOperator,
+    };
+}
+
+class IndecentFlags {
+    final bool? hasExportAssignment;
+    final bool? isAbstract;
+    final bool? isConst;
+    final bool? isExported;
+    final bool? isLet;
+    final bool? isPrivate;
+    final bool? isProtected;
+
+    IndecentFlags({
+        this.hasExportAssignment,
+        this.isAbstract,
+        this.isConst,
+        this.isExported,
+        this.isLet,
+        this.isPrivate,
+        this.isProtected,
+    });
+
+    factory IndecentFlags.fromJson(Map<String, dynamic> json) => IndecentFlags(
+        hasExportAssignment: json["hasExportAssignment"],
+        isAbstract: json["isAbstract"],
+        isConst: json["isConst"],
+        isExported: json["isExported"],
+        isLet: json["isLet"],
+        isPrivate: json["isPrivate"],
+        isProtected: json["isProtected"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "hasExportAssignment": hasExportAssignment,
+        "isAbstract": isAbstract,
+        "isConst": isConst,
+        "isExported": isExported,
+        "isLet": isLet,
+        "isPrivate": isPrivate,
+        "isProtected": isProtected,
+    };
+}
+
+enum FluffyKindString {
+    MODULE,
+    CLASS,
+    VARIABLE,
+    FUNCTION,
+    INTERFACE,
+    ENUMERATION,
+    OBJECT_LITERAL,
+    TYPE_ALIAS
+}
+
+final fluffyKindStringValues = EnumValues({
+    "Module": FluffyKindString.MODULE,
+    "Class": FluffyKindString.CLASS,
+    "Variable": FluffyKindString.VARIABLE,
+    "Function": FluffyKindString.FUNCTION,
+    "Interface": FluffyKindString.INTERFACE,
+    "Enumeration": FluffyKindString.ENUMERATION,
+    "Object literal": FluffyKindString.OBJECT_LITERAL,
+    "Type alias": FluffyKindString.TYPE_ALIAS
+});
+
+class StickySignature {
+    final StickyComment comment;
+    final IndigoFlags flags;
+    final int id;
+    final int kind;
+    final SignatureKindString kindString;
+    final String name;
+    final List<TentacledParameter>? parameters;
+    final CunningType type;
+    final List<GetSignature>? typeParameter;
+
+    StickySignature({
+        required this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.parameters,
+        required this.type,
+        this.typeParameter,
+    });
+
+    factory StickySignature.fromJson(Map<String, dynamic> json) => StickySignature(
+        comment: StickyComment.fromJson(json["comment"]),
+        flags: IndigoFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: signatureKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        parameters: json["parameters"] == null ? null : List<TentacledParameter>.from(json["parameters"]!.map((x) => TentacledParameter.fromJson(x))),
+        type: CunningType.fromJson(json["type"]),
+        typeParameter: json["typeParameter"] == null ? null : List<GetSignature>.from(json["typeParameter"]!.map((x) => GetSignature.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": signatureKindStringValues.reverse[kindString],
+        "name": name,
+        "parameters": parameters == null ? null : List<dynamic>.from(parameters!.map((x) => x.toJson())),
+        "type": type.toJson(),
+        "typeParameter": typeParameter == null ? null : List<dynamic>.from(typeParameter!.map((x) => x.toJson())),
+    };
+}
+
+class TentacledParameter {
+    final TentacledComment? comment;
+    final String? defaultValue;
+    final TentacledFlags flags;
+    final int id;
+    final int kind;
+    final ParameterKindString kindString;
+    final String name;
+    final String? originalName;
+    final AmbitiousType type;
+
+    TentacledParameter({
+        this.comment,
+        this.defaultValue,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.originalName,
+        required this.type,
+    });
+
+    factory TentacledParameter.fromJson(Map<String, dynamic> json) => TentacledParameter(
+        comment: json["comment"] == null ? null : TentacledComment.fromJson(json["comment"]),
+        defaultValue: json["defaultValue"],
+        flags: TentacledFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: parameterKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        originalName: json["originalName"],
+        type: AmbitiousType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "defaultValue": defaultValue,
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": parameterKindStringValues.reverse[kindString],
+        "name": name,
+        "originalName": originalName,
+        "type": type.toJson(),
+    };
+}
+
+class AmbitiousType {
+    final TentacledDeclaration? declaration;
+    final ElementType? elementType;
+    final int? id;
+    final String? name;
+    final TypeEnum type;
+    final List<ElementType>? typeArguments;
+
+    AmbitiousType({
+        this.declaration,
+        this.elementType,
+        this.id,
+        this.name,
+        required this.type,
+        this.typeArguments,
+    });
+
+    factory AmbitiousType.fromJson(Map<String, dynamic> json) => AmbitiousType(
+        declaration: json["declaration"] == null ? null : TentacledDeclaration.fromJson(json["declaration"]),
+        elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
+        id: json["id"],
+        name: json["name"],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "elementType": elementType?.toJson(),
+        "id": id,
+        "name": name,
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+    };
+}
+
+class TentacledDeclaration {
+    final List<IndigoChild>? children;
+    final GetSignatureFlags flags;
+    final List<Group>? groups;
+    final int id;
+    final IndexSignatureElement? indexSignature;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<GetSignature>? signatures;
+    final List<Source> sources;
+
+    TentacledDeclaration({
+        this.children,
+        required this.flags,
+        this.groups,
+        required this.id,
+        this.indexSignature,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.signatures,
+        required this.sources,
+    });
+
+    factory TentacledDeclaration.fromJson(Map<String, dynamic> json) => TentacledDeclaration(
+        children: json["children"] == null ? null : List<IndigoChild>.from(json["children"]!.map((x) => IndigoChild.fromJson(x))),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        indexSignature: json["indexSignature"] == null ? null : IndexSignatureElement.fromJson(json["indexSignature"]),
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        signatures: json["signatures"] == null ? null : List<GetSignature>.from(json["signatures"]!.map((x) => GetSignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "indexSignature": indexSignature?.toJson(),
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+    };
+}
+
+class IndigoChild {
+    final FluffyComment comment;
+    final String? defaultValue;
+    final FluffyFlags flags;
+    final int id;
+    final int kind;
+    final PurpleKindString kindString;
+    final String name;
+    final List<Source> sources;
+    final IndecentType type;
+
+    IndigoChild({
+        required this.comment,
+        this.defaultValue,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.sources,
+        required this.type,
+    });
+
+    factory IndigoChild.fromJson(Map<String, dynamic> json) => IndigoChild(
+        comment: FluffyComment.fromJson(json["comment"]),
+        defaultValue: json["defaultValue"],
+        flags: FluffyFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: purpleKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: IndecentType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment.toJson(),
+        "defaultValue": defaultValue,
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": purpleKindStringValues.reverse[kindString],
+        "name": name,
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class CunningType {
+    final PurpleDeclaration? declaration;
+    final int? id;
+    final Name? name;
+    final TypeEnum type;
+    final List<ElementType>? typeArguments;
+
+    CunningType({
+        this.declaration,
+        this.id,
+        this.name,
+        required this.type,
+        this.typeArguments,
+    });
+
+    factory CunningType.fromJson(Map<String, dynamic> json) => CunningType(
+        declaration: json["declaration"] == null ? null : PurpleDeclaration.fromJson(json["declaration"]),
+        id: json["id"],
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<ElementType>.from(json["typeArguments"]!.map((x) => ElementType.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "id": id,
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+    };
+}
+
+class MagentaType {
+    final StickyDeclaration? declaration;
+    final ElementType? elementType;
+    final List<ExtendedBy>? elements;
+    final int? id;
+    final String? name;
+    final TypeEnum type;
+    final List<FluffyTypeArgument>? typeArguments;
+    final List<ExtendedBy>? types;
+    final String? value;
+
+    MagentaType({
+        this.declaration,
+        this.elementType,
+        this.elements,
+        this.id,
+        this.name,
+        required this.type,
+        this.typeArguments,
+        this.types,
+        this.value,
+    });
+
+    factory MagentaType.fromJson(Map<String, dynamic> json) => MagentaType(
+        declaration: json["declaration"] == null ? null : StickyDeclaration.fromJson(json["declaration"]),
+        elementType: json["elementType"] == null ? null : ElementType.fromJson(json["elementType"]),
+        elements: json["elements"] == null ? null : List<ExtendedBy>.from(json["elements"]!.map((x) => ExtendedBy.fromJson(x))),
+        id: json["id"],
+        name: json["name"],
+        type: typeEnumValues.map[json["type"]]!,
+        typeArguments: json["typeArguments"] == null ? null : List<FluffyTypeArgument>.from(json["typeArguments"]!.map((x) => FluffyTypeArgument.fromJson(x))),
+        types: json["types"] == null ? null : List<ExtendedBy>.from(json["types"]!.map((x) => ExtendedBy.fromJson(x))),
+        value: json["value"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "elementType": elementType?.toJson(),
+        "elements": elements == null ? null : List<dynamic>.from(elements!.map((x) => x.toJson())),
+        "id": id,
+        "name": name,
+        "type": typeEnumValues.reverse[type],
+        "typeArguments": typeArguments == null ? null : List<dynamic>.from(typeArguments!.map((x) => x.toJson())),
+        "types": types == null ? null : List<dynamic>.from(types!.map((x) => x.toJson())),
+        "value": value,
+    };
+}
+
+class StickyDeclaration {
+    final List<IndecentChild>? children;
+    final GetSignatureFlags flags;
+    final List<Group>? groups;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<GetSignature> signatures;
+    final List<Source> sources;
+
+    StickyDeclaration({
+        this.children,
+        required this.flags,
+        this.groups,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.signatures,
+        required this.sources,
+    });
+
+    factory StickyDeclaration.fromJson(Map<String, dynamic> json) => StickyDeclaration(
+        children: json["children"] == null ? null : List<IndecentChild>.from(json["children"]!.map((x) => IndecentChild.fromJson(x))),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        signatures: List<GetSignature>.from(json["signatures"].map((x) => GetSignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "signatures": List<dynamic>.from(signatures.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+    };
+}
+
+class IndecentChild {
+    final FluffyFlags flags;
+    final int id;
+    final int kind;
+    final PurpleKindString kindString;
+    final String name;
+    final List<Source> sources;
+    final FriskyType type;
+
+    IndecentChild({
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        required this.sources,
+        required this.type,
+    });
+
+    factory IndecentChild.fromJson(Map<String, dynamic> json) => IndecentChild(
+        flags: FluffyFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: purpleKindStringValues.map[json["kindString"]]!,
+        name: json["name"],
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+        type: FriskyType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": purpleKindStringValues.reverse[kindString],
+        "name": name,
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+        "type": type.toJson(),
+    };
+}
+
+class FriskyType {
+    final IndigoDeclaration? declaration;
+    final Name? name;
+    final TypeEnum type;
+
+    FriskyType({
+        this.declaration,
+        this.name,
+        required this.type,
+    });
+
+    factory FriskyType.fromJson(Map<String, dynamic> json) => FriskyType(
+        declaration: json["declaration"] == null ? null : IndigoDeclaration.fromJson(json["declaration"]),
+        name: nameValues.map[json["name"]],
+        type: typeEnumValues.map[json["type"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "declaration": declaration?.toJson(),
+        "name": nameValues.reverse[name],
+        "type": typeEnumValues.reverse[type],
+    };
+}
+
+class IndigoDeclaration {
+    final List<GetSignature>? children;
+    final GetSignatureFlags flags;
+    final List<Group>? groups;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final List<GetSignature>? signatures;
+    final List<Source> sources;
+
+    IndigoDeclaration({
+        this.children,
+        required this.flags,
+        this.groups,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.signatures,
+        required this.sources,
+    });
+
+    factory IndigoDeclaration.fromJson(Map<String, dynamic> json) => IndigoDeclaration(
+        children: json["children"] == null ? null : List<GetSignature>.from(json["children"]!.map((x) => GetSignature.fromJson(x))),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        groups: json["groups"] == null ? null : List<Group>.from(json["groups"]!.map((x) => Group.fromJson(x))),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        signatures: json["signatures"] == null ? null : List<GetSignature>.from(json["signatures"]!.map((x) => GetSignature.fromJson(x))),
+        sources: List<Source>.from(json["sources"].map((x) => Source.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "children": children == null ? null : List<dynamic>.from(children!.map((x) => x.toJson())),
+        "flags": flags.toJson(),
+        "groups": groups == null ? null : List<dynamic>.from(groups!.map((x) => x.toJson())),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "signatures": signatures == null ? null : List<dynamic>.from(signatures!.map((x) => x.toJson())),
+        "sources": List<dynamic>.from(sources.map((x) => x.toJson())),
+    };
+}
+
+class FluffyTypeArgument {
+    final TypeEnum type;
+    final List<ElementType> types;
+
+    FluffyTypeArgument({
+        required this.type,
+        required this.types,
+    });
+
+    factory FluffyTypeArgument.fromJson(Map<String, dynamic> json) => FluffyTypeArgument(
+        type: typeEnumValues.map[json["type"]]!,
+        types: List<ElementType>.from(json["types"].map((x) => ElementType.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "type": typeEnumValues.reverse[type],
+        "types": List<dynamic>.from(types.map((x) => x.toJson())),
+    };
+}
+
+class TypeParameter {
+    final PurpleComment? comment;
+    final GetSignatureFlags flags;
+    final int id;
+    final int kind;
+    final String kindString;
+    final String name;
+    final MischievousType? type;
+
+    TypeParameter({
+        this.comment,
+        required this.flags,
+        required this.id,
+        required this.kind,
+        required this.kindString,
+        required this.name,
+        this.type,
+    });
+
+    factory TypeParameter.fromJson(Map<String, dynamic> json) => TypeParameter(
+        comment: json["comment"] == null ? null : PurpleComment.fromJson(json["comment"]),
+        flags: GetSignatureFlags.fromJson(json["flags"]),
+        id: json["id"],
+        kind: json["kind"],
+        kindString: json["kindString"],
+        name: json["name"],
+        type: json["type"] == null ? null : MischievousType.fromJson(json["type"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comment": comment?.toJson(),
+        "flags": flags.toJson(),
+        "id": id,
+        "kind": kind,
+        "kindString": kindString,
+        "name": name,
+        "type": type?.toJson(),
+    };
+}
+
+class MischievousType {
+    final int? id;
+    final Name? name;
+    final ElementType? target;
+    final String type;
+    final String? typeOperator;
+
+    MischievousType({
+        this.id,
+        this.name,
+        this.target,
+        required this.type,
+        this.typeOperator,
+    });
+
+    factory MischievousType.fromJson(Map<String, dynamic> json) => MischievousType(
+        id: json["id"],
+        name: nameValues.map[json["name"]],
+        target: json["target"] == null ? null : ElementType.fromJson(json["target"]),
+        type: json["type"],
+        typeOperator: json["operator"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "id": id,
+        "name": nameValues.reverse[name],
+        "target": target?.toJson(),
+        "type": type,
+        "operator": typeOperator,
+    };
+}
+
+class IndecentComment {
+    final String shortText;
+    final List<Tag>? tags;
+
+    IndecentComment({
+        required this.shortText,
+        this.tags,
+    });
+
+    factory IndecentComment.fromJson(Map<String, dynamic> json) => IndecentComment(
+        shortText: json["shortText"],
+        tags: json["tags"] == null ? null : List<Tag>.from(json["tags"]!.map((x) => Tag.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "shortText": shortText,
+        "tags": tags == null ? null : List<dynamic>.from(tags!.map((x) => x.toJson())),
+    };
+}
+
+enum TentacledKindString {
+    EXTERNAL_MODULE
+}
+
+final tentacledKindStringValues = EnumValues({
+    "External module": TentacledKindString.EXTERNAL_MODULE
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/dart/test/inputs/json/priority/combinations3.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations3.json/default/TopLevel.dart
new file mode 100644
index 0000000..f08aef7
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/combinations3.json/default/TopLevel.dart
@@ -0,0 +1,1537 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<dynamic> juror;
+    final List<dynamic> kongoni;
+    final List<dynamic> ladronism;
+    final List<dynamic> landlubberly;
+    final List<dynamic> listener;
+    final List<dynamic> lupus;
+    final List<Maslin> maslin;
+    final List<dynamic> monazite;
+    final List<dynamic> monoliteral;
+    final List<dynamic> monotheistically;
+    final List<dynamic> montage;
+    final List<dynamic> moralness;
+    final List<MonaziteClass?> mowra;
+    final List<dynamic> mulishly;
+    final List<dynamic> myoscope;
+    final List<List<int?>?> nach;
+    final List<dynamic> neuromastic;
+    final List<Noncontributing> noncontributing;
+    final List<dynamic> nonnervous;
+    final List<dynamic> nonvaluation;
+    final List<dynamic> occupationalist;
+    final List<dynamic> outrival;
+    final List<dynamic> paleographically;
+    final List<dynamic> pamphletwise;
+    final List<dynamic> pediatrics;
+    final List<bool> perceptive;
+    final List<dynamic> piaculum;
+    final List<dynamic> piccadilly;
+    final List<dynamic> piffler;
+    final List<dynamic> pithful;
+    final List<dynamic> placuntitis;
+    final List<dynamic> plectopterous;
+    final List<Pneumocele?> pneumocele;
+    final List<dynamic> poliorcetic;
+    final List<dynamic> poormaster;
+    final List<dynamic> potwhisky;
+    final List<dynamic> practicalizer;
+    final List<dynamic> prefreshman;
+    final List<dynamic> prehensility;
+    final List<dynamic> prevoidance;
+    final List<Map<String, int?>> probant;
+    final List<dynamic> protext;
+
+    TopLevel({
+        required this.juror,
+        required this.kongoni,
+        required this.ladronism,
+        required this.landlubberly,
+        required this.listener,
+        required this.lupus,
+        required this.maslin,
+        required this.monazite,
+        required this.monoliteral,
+        required this.monotheistically,
+        required this.montage,
+        required this.moralness,
+        required this.mowra,
+        required this.mulishly,
+        required this.myoscope,
+        required this.nach,
+        required this.neuromastic,
+        required this.noncontributing,
+        required this.nonnervous,
+        required this.nonvaluation,
+        required this.occupationalist,
+        required this.outrival,
+        required this.paleographically,
+        required this.pamphletwise,
+        required this.pediatrics,
+        required this.perceptive,
+        required this.piaculum,
+        required this.piccadilly,
+        required this.piffler,
+        required this.pithful,
+        required this.placuntitis,
+        required this.plectopterous,
+        required this.pneumocele,
+        required this.poliorcetic,
+        required this.poormaster,
+        required this.potwhisky,
+        required this.practicalizer,
+        required this.prefreshman,
+        required this.prehensility,
+        required this.prevoidance,
+        required this.probant,
+        required this.protext,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        juror: List<dynamic>.from(json["juror"].map((x) => x)),
+        kongoni: List<dynamic>.from(json["kongoni"].map((x) => x)),
+        ladronism: List<dynamic>.from(json["ladronism"].map((x) => x)),
+        landlubberly: List<dynamic>.from(json["landlubberly"].map((x) => x)),
+        listener: List<dynamic>.from(json["listener"].map((x) => x)),
+        lupus: List<dynamic>.from(json["lupus"].map((x) => x)),
+        maslin: List<Maslin>.from(json["maslin"].map((x) => Maslin.fromJson(x))),
+        monazite: List<dynamic>.from(json["monazite"].map((x) => x)),
+        monoliteral: List<dynamic>.from(json["monoliteral"].map((x) => x)),
+        monotheistically: List<dynamic>.from(json["monotheistically"].map((x) => x)),
+        montage: List<dynamic>.from(json["montage"].map((x) => x)),
+        moralness: List<dynamic>.from(json["moralness"].map((x) => x)),
+        mowra: List<MonaziteClass?>.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromJson(x))),
+        mulishly: List<dynamic>.from(json["mulishly"].map((x) => x)),
+        myoscope: List<dynamic>.from(json["myoscope"].map((x) => x)),
+        nach: List<List<int?>?>.from(json["nach"].map((x) => x == null ? null : List<int?>.from(x!.map((x) => x)))),
+        neuromastic: List<dynamic>.from(json["neuromastic"].map((x) => x)),
+        noncontributing: List<Noncontributing>.from(json["noncontributing"].map((x) => Noncontributing.fromJson(x))),
+        nonnervous: List<dynamic>.from(json["nonnervous"].map((x) => x)),
+        nonvaluation: List<dynamic>.from(json["nonvaluation"].map((x) => x)),
+        occupationalist: List<dynamic>.from(json["occupationalist"].map((x) => x)),
+        outrival: List<dynamic>.from(json["outrival"].map((x) => x)),
+        paleographically: List<dynamic>.from(json["paleographically"].map((x) => x)),
+        pamphletwise: List<dynamic>.from(json["pamphletwise"].map((x) => x)),
+        pediatrics: List<dynamic>.from(json["pediatrics"].map((x) => x)),
+        perceptive: List<bool>.from(json["perceptive"].map((x) => x)),
+        piaculum: List<dynamic>.from(json["piaculum"].map((x) => x)),
+        piccadilly: List<dynamic>.from(json["piccadilly"].map((x) => x)),
+        piffler: List<dynamic>.from(json["piffler"].map((x) => x)),
+        pithful: List<dynamic>.from(json["pithful"].map((x) => x)),
+        placuntitis: List<dynamic>.from(json["placuntitis"].map((x) => x)),
+        plectopterous: List<dynamic>.from(json["plectopterous"].map((x) => x)),
+        pneumocele: List<Pneumocele?>.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromJson(x))),
+        poliorcetic: List<dynamic>.from(json["poliorcetic"].map((x) => x)),
+        poormaster: List<dynamic>.from(json["poormaster"].map((x) => x)),
+        potwhisky: List<dynamic>.from(json["potwhisky"].map((x) => x)),
+        practicalizer: List<dynamic>.from(json["practicalizer"].map((x) => x)),
+        prefreshman: List<dynamic>.from(json["prefreshman"].map((x) => x)),
+        prehensility: List<dynamic>.from(json["prehensility"].map((x) => x)),
+        prevoidance: List<dynamic>.from(json["prevoidance"].map((x) => x)),
+        probant: List<Map<String, int?>>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry<String, int?>(k, v)))),
+        protext: List<dynamic>.from(json["protext"].map((x) => x)),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "juror": List<dynamic>.from(juror.map((x) => x)),
+        "kongoni": List<dynamic>.from(kongoni.map((x) => x)),
+        "ladronism": List<dynamic>.from(ladronism.map((x) => x)),
+        "landlubberly": List<dynamic>.from(landlubberly.map((x) => x)),
+        "listener": List<dynamic>.from(listener.map((x) => x)),
+        "lupus": List<dynamic>.from(lupus.map((x) => x)),
+        "maslin": List<dynamic>.from(maslin.map((x) => x.toJson())),
+        "monazite": List<dynamic>.from(monazite.map((x) => x)),
+        "monoliteral": List<dynamic>.from(monoliteral.map((x) => x)),
+        "monotheistically": List<dynamic>.from(monotheistically.map((x) => x)),
+        "montage": List<dynamic>.from(montage.map((x) => x)),
+        "moralness": List<dynamic>.from(moralness.map((x) => x)),
+        "mowra": List<dynamic>.from(mowra.map((x) => x?.toJson())),
+        "mulishly": List<dynamic>.from(mulishly.map((x) => x)),
+        "myoscope": List<dynamic>.from(myoscope.map((x) => x)),
+        "nach": List<dynamic>.from(nach.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
+        "neuromastic": List<dynamic>.from(neuromastic.map((x) => x)),
+        "noncontributing": List<dynamic>.from(noncontributing.map((x) => x.toJson())),
+        "nonnervous": List<dynamic>.from(nonnervous.map((x) => x)),
+        "nonvaluation": List<dynamic>.from(nonvaluation.map((x) => x)),
+        "occupationalist": List<dynamic>.from(occupationalist.map((x) => x)),
+        "outrival": List<dynamic>.from(outrival.map((x) => x)),
+        "paleographically": List<dynamic>.from(paleographically.map((x) => x)),
+        "pamphletwise": List<dynamic>.from(pamphletwise.map((x) => x)),
+        "pediatrics": List<dynamic>.from(pediatrics.map((x) => x)),
+        "perceptive": List<dynamic>.from(perceptive.map((x) => x)),
+        "piaculum": List<dynamic>.from(piaculum.map((x) => x)),
+        "piccadilly": List<dynamic>.from(piccadilly.map((x) => x)),
+        "piffler": List<dynamic>.from(piffler.map((x) => x)),
+        "pithful": List<dynamic>.from(pithful.map((x) => x)),
+        "placuntitis": List<dynamic>.from(placuntitis.map((x) => x)),
+        "plectopterous": List<dynamic>.from(plectopterous.map((x) => x)),
+        "pneumocele": List<dynamic>.from(pneumocele.map((x) => x?.toJson())),
+        "poliorcetic": List<dynamic>.from(poliorcetic.map((x) => x)),
+        "poormaster": List<dynamic>.from(poormaster.map((x) => x)),
+        "potwhisky": List<dynamic>.from(potwhisky.map((x) => x)),
+        "practicalizer": List<dynamic>.from(practicalizer.map((x) => x)),
+        "prefreshman": List<dynamic>.from(prefreshman.map((x) => x)),
+        "prehensility": List<dynamic>.from(prehensility.map((x) => x)),
+        "prevoidance": List<dynamic>.from(prevoidance.map((x) => x)),
+        "probant": List<dynamic>.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry<String, dynamic>(k, v)))),
+        "protext": List<dynamic>.from(protext.map((x) => x)),
+    };
+}
+
+class JurorClass {
+    final dynamic adipsy;
+    final dynamic auxiliator;
+    final dynamic benda;
+    final dynamic benjamin;
+    final dynamic brandling;
+    final dynamic epicurishly;
+    final dynamic eremochaetous;
+    final dynamic marten;
+    final dynamic monocline;
+    final dynamic olea;
+    final dynamic palgat;
+    final dynamic pennyworth;
+    final dynamic pioury;
+    final dynamic pragmatistic;
+    final dynamic stylelessness;
+    final dynamic systematical;
+    final dynamic thready;
+    final dynamic uncontemporary;
+    final dynamic uncouched;
+    final dynamic uninhabitedness;
+
+    JurorClass({
+        required this.adipsy,
+        required this.auxiliator,
+        required this.benda,
+        required this.benjamin,
+        required this.brandling,
+        required this.epicurishly,
+        required this.eremochaetous,
+        required this.marten,
+        required this.monocline,
+        required this.olea,
+        required this.palgat,
+        required this.pennyworth,
+        required this.pioury,
+        required this.pragmatistic,
+        required this.stylelessness,
+        required this.systematical,
+        required this.thready,
+        required this.uncontemporary,
+        required this.uncouched,
+        required this.uninhabitedness,
+    });
+
+    factory JurorClass.fromJson(Map<String, dynamic> json) => JurorClass(
+        adipsy: json["adipsy"],
+        auxiliator: json["auxiliator"],
+        benda: json["benda"],
+        benjamin: json["benjamin"],
+        brandling: json["brandling"],
+        epicurishly: json["epicurishly"],
+        eremochaetous: json["eremochaetous"],
+        marten: json["marten"],
+        monocline: json["monocline"],
+        olea: json["Olea"],
+        palgat: json["palgat"],
+        pennyworth: json["pennyworth"],
+        pioury: json["pioury"],
+        pragmatistic: json["pragmatistic"],
+        stylelessness: json["stylelessness"],
+        systematical: json["systematical"],
+        thready: json["thready"],
+        uncontemporary: json["uncontemporary"],
+        uncouched: json["uncouched"],
+        uninhabitedness: json["uninhabitedness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "adipsy": adipsy,
+        "auxiliator": auxiliator,
+        "benda": benda,
+        "benjamin": benjamin,
+        "brandling": brandling,
+        "epicurishly": epicurishly,
+        "eremochaetous": eremochaetous,
+        "marten": marten,
+        "monocline": monocline,
+        "Olea": olea,
+        "palgat": palgat,
+        "pennyworth": pennyworth,
+        "pioury": pioury,
+        "pragmatistic": pragmatistic,
+        "stylelessness": stylelessness,
+        "systematical": systematical,
+        "thready": thready,
+        "uncontemporary": uncontemporary,
+        "uncouched": uncouched,
+        "uninhabitedness": uninhabitedness,
+    };
+}
+
+class LadronismClass {
+    final dynamic acclaimer;
+    final dynamic achree;
+    final dynamic base;
+    final dynamic conundrumize;
+    final dynamic degerminator;
+    final dynamic describable;
+    final dynamic exasperatedly;
+    final dynamic heroine;
+    final dynamic indazin;
+    final dynamic luteous;
+    final dynamic papular;
+    final dynamic pritch;
+    final dynamic prodenia;
+    final dynamic seege;
+    final dynamic shopgirl;
+    final dynamic tragedietta;
+    final dynamic unsparse;
+    final dynamic uplook;
+    final dynamic vermiformis;
+    final dynamic whafabout;
+
+    LadronismClass({
+        required this.acclaimer,
+        required this.achree,
+        required this.base,
+        required this.conundrumize,
+        required this.degerminator,
+        required this.describable,
+        required this.exasperatedly,
+        required this.heroine,
+        required this.indazin,
+        required this.luteous,
+        required this.papular,
+        required this.pritch,
+        required this.prodenia,
+        required this.seege,
+        required this.shopgirl,
+        required this.tragedietta,
+        required this.unsparse,
+        required this.uplook,
+        required this.vermiformis,
+        required this.whafabout,
+    });
+
+    factory LadronismClass.fromJson(Map<String, dynamic> json) => LadronismClass(
+        acclaimer: json["acclaimer"],
+        achree: json["achree"],
+        base: json["base"],
+        conundrumize: json["conundrumize"],
+        degerminator: json["degerminator"],
+        describable: json["describable"],
+        exasperatedly: json["exasperatedly"],
+        heroine: json["heroine"],
+        indazin: json["indazin"],
+        luteous: json["luteous"],
+        papular: json["papular"],
+        pritch: json["pritch"],
+        prodenia: json["Prodenia"],
+        seege: json["seege"],
+        shopgirl: json["shopgirl"],
+        tragedietta: json["tragedietta"],
+        unsparse: json["unsparse"],
+        uplook: json["uplook"],
+        vermiformis: json["vermiformis"],
+        whafabout: json["whafabout"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "acclaimer": acclaimer,
+        "achree": achree,
+        "base": base,
+        "conundrumize": conundrumize,
+        "degerminator": degerminator,
+        "describable": describable,
+        "exasperatedly": exasperatedly,
+        "heroine": heroine,
+        "indazin": indazin,
+        "luteous": luteous,
+        "papular": papular,
+        "pritch": pritch,
+        "Prodenia": prodenia,
+        "seege": seege,
+        "shopgirl": shopgirl,
+        "tragedietta": tragedietta,
+        "unsparse": unsparse,
+        "uplook": uplook,
+        "vermiformis": vermiformis,
+        "whafabout": whafabout,
+    };
+}
+
+class LandlubberlyClass {
+    final dynamic acropoleis;
+    final dynamic aminate;
+    final dynamic amyraldism;
+    final dynamic bipenniform;
+    final dynamic bugre;
+    final dynamic calycule;
+    final dynamic caoutchouc;
+    final dynamic disprover;
+    final dynamic fitroot;
+    final dynamic fulgently;
+    final dynamic kickup;
+    final dynamic laevoversion;
+    final dynamic moter;
+    final dynamic objectivity;
+    final dynamic posterity;
+    final dynamic postnuptial;
+    final dynamic precedentary;
+    final dynamic saddling;
+    final dynamic subcurrent;
+    final dynamic unrecriminative;
+
+    LandlubberlyClass({
+        required this.acropoleis,
+        required this.aminate,
+        required this.amyraldism,
+        required this.bipenniform,
+        required this.bugre,
+        required this.calycule,
+        required this.caoutchouc,
+        required this.disprover,
+        required this.fitroot,
+        required this.fulgently,
+        required this.kickup,
+        required this.laevoversion,
+        required this.moter,
+        required this.objectivity,
+        required this.posterity,
+        required this.postnuptial,
+        required this.precedentary,
+        required this.saddling,
+        required this.subcurrent,
+        required this.unrecriminative,
+    });
+
+    factory LandlubberlyClass.fromJson(Map<String, dynamic> json) => LandlubberlyClass(
+        acropoleis: json["acropoleis"],
+        aminate: json["aminate"],
+        amyraldism: json["Amyraldism"],
+        bipenniform: json["bipenniform"],
+        bugre: json["bugre"],
+        calycule: json["calycule"],
+        caoutchouc: json["caoutchouc"],
+        disprover: json["disprover"],
+        fitroot: json["fitroot"],
+        fulgently: json["fulgently"],
+        kickup: json["kickup"],
+        laevoversion: json["laevoversion"],
+        moter: json["moter"],
+        objectivity: json["objectivity"],
+        posterity: json["posterity"],
+        postnuptial: json["postnuptial"],
+        precedentary: json["precedentary"],
+        saddling: json["saddling"],
+        subcurrent: json["subcurrent"],
+        unrecriminative: json["unrecriminative"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "acropoleis": acropoleis,
+        "aminate": aminate,
+        "Amyraldism": amyraldism,
+        "bipenniform": bipenniform,
+        "bugre": bugre,
+        "calycule": calycule,
+        "caoutchouc": caoutchouc,
+        "disprover": disprover,
+        "fitroot": fitroot,
+        "fulgently": fulgently,
+        "kickup": kickup,
+        "laevoversion": laevoversion,
+        "moter": moter,
+        "objectivity": objectivity,
+        "posterity": posterity,
+        "postnuptial": postnuptial,
+        "precedentary": precedentary,
+        "saddling": saddling,
+        "subcurrent": subcurrent,
+        "unrecriminative": unrecriminative,
+    };
+}
+
+class LupusClass {
+    final double? catharticalness;
+    final int? chirotherium;
+    final int? chlorioninae;
+    final int? corvinae;
+    final int? crassina;
+    final String? disdiapason;
+    final int? exiguity;
+    final int? farcist;
+    final int? holographical;
+    final bool? homocerc;
+    final int? ichthyophagan;
+    final int? implacable;
+    final dynamic nonbookish;
+    final int? outshiner;
+    final int? overweather;
+    final int? protonegroid;
+    final int? shallowish;
+    final int? snoke;
+    final int? snout;
+    final int? surveillance;
+    final int? threshingtime;
+    final int? thysanocarpus;
+    final int? unsignificantly;
+    final int? unsnap;
+    final int? vendible;
+
+    LupusClass({
+        this.catharticalness,
+        this.chirotherium,
+        this.chlorioninae,
+        this.corvinae,
+        this.crassina,
+        this.disdiapason,
+        this.exiguity,
+        this.farcist,
+        this.holographical,
+        this.homocerc,
+        this.ichthyophagan,
+        this.implacable,
+        this.nonbookish,
+        this.outshiner,
+        this.overweather,
+        this.protonegroid,
+        this.shallowish,
+        this.snoke,
+        this.snout,
+        this.surveillance,
+        this.threshingtime,
+        this.thysanocarpus,
+        this.unsignificantly,
+        this.unsnap,
+        this.vendible,
+    });
+
+    factory LupusClass.fromJson(Map<String, dynamic> json) => LupusClass(
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chlorioninae: json["Chlorioninae"],
+        corvinae: json["Corvinae"],
+        crassina: json["Crassina"],
+        disdiapason: json["disdiapason"],
+        exiguity: json["exiguity"],
+        farcist: json["farcist"],
+        holographical: json["holographical"],
+        homocerc: json["homocerc"],
+        ichthyophagan: json["ichthyophagan"],
+        implacable: json["implacable"],
+        nonbookish: json["nonbookish"],
+        outshiner: json["outshiner"],
+        overweather: json["overweather"],
+        protonegroid: json["protonegroid"],
+        shallowish: json["shallowish"],
+        snoke: json["snoke"],
+        snout: json["snout"],
+        surveillance: json["surveillance"],
+        threshingtime: json["threshingtime"],
+        thysanocarpus: json["Thysanocarpus"],
+        unsignificantly: json["unsignificantly"],
+        unsnap: json["unsnap"],
+        vendible: json["vendible"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "Chlorioninae": chlorioninae,
+        "Corvinae": corvinae,
+        "Crassina": crassina,
+        "disdiapason": disdiapason,
+        "exiguity": exiguity,
+        "farcist": farcist,
+        "holographical": holographical,
+        "homocerc": homocerc,
+        "ichthyophagan": ichthyophagan,
+        "implacable": implacable,
+        "nonbookish": nonbookish,
+        "outshiner": outshiner,
+        "overweather": overweather,
+        "protonegroid": protonegroid,
+        "shallowish": shallowish,
+        "snoke": snoke,
+        "snout": snout,
+        "surveillance": surveillance,
+        "threshingtime": threshingtime,
+        "Thysanocarpus": thysanocarpus,
+        "unsignificantly": unsignificantly,
+        "unsnap": unsnap,
+        "vendible": vendible,
+    };
+}
+
+class Maslin {
+    final int? alicant;
+    final dynamic antiatonement;
+    final int? anticorrosive;
+    final dynamic aphidozer;
+    final dynamic bakuninist;
+    final int? be;
+    final double? catharticalness;
+    final int? chirotherium;
+    final int? chub;
+    final int? cuprosilicon;
+    final int? curtailedly;
+    final int? dellenite;
+    final int? dimitry;
+    final String? disdiapason;
+    final dynamic edifying;
+    final int? ethmoiditis;
+    final dynamic gastralgy;
+    final int? goatherd;
+    final int? hammerdress;
+    final dynamic hangfire;
+    final bool? homocerc;
+    final int? lacunosity;
+    final dynamic longiloquence;
+    final int? mameliere;
+    final dynamic motherless;
+    final dynamic nonbookish;
+    final dynamic noncorrodible;
+    final dynamic nonsensicality;
+    final int? oafishly;
+    final dynamic pfund;
+    final dynamic preadvisory;
+    final dynamic retroflexed;
+    final int? saccharulmic;
+    final int? scowlful;
+    final dynamic secluded;
+    final dynamic slackage;
+    final int? sphaeridial;
+    final dynamic spondulics;
+    final int? subsecive;
+    final dynamic swellmobsman;
+    final int? trachyglossate;
+    final dynamic trialogue;
+    final int? unassuaged;
+    final dynamic ungross;
+    final dynamic unjudiciously;
+
+    Maslin({
+        this.alicant,
+        this.antiatonement,
+        this.anticorrosive,
+        this.aphidozer,
+        this.bakuninist,
+        this.be,
+        this.catharticalness,
+        this.chirotherium,
+        this.chub,
+        this.cuprosilicon,
+        this.curtailedly,
+        this.dellenite,
+        this.dimitry,
+        this.disdiapason,
+        this.edifying,
+        this.ethmoiditis,
+        this.gastralgy,
+        this.goatherd,
+        this.hammerdress,
+        this.hangfire,
+        this.homocerc,
+        this.lacunosity,
+        this.longiloquence,
+        this.mameliere,
+        this.motherless,
+        this.nonbookish,
+        this.noncorrodible,
+        this.nonsensicality,
+        this.oafishly,
+        this.pfund,
+        this.preadvisory,
+        this.retroflexed,
+        this.saccharulmic,
+        this.scowlful,
+        this.secluded,
+        this.slackage,
+        this.sphaeridial,
+        this.spondulics,
+        this.subsecive,
+        this.swellmobsman,
+        this.trachyglossate,
+        this.trialogue,
+        this.unassuaged,
+        this.ungross,
+        this.unjudiciously,
+    });
+
+    factory Maslin.fromJson(Map<String, dynamic> json) => Maslin(
+        alicant: json["Alicant"],
+        antiatonement: json["antiatonement"],
+        anticorrosive: json["anticorrosive"],
+        aphidozer: json["aphidozer"],
+        bakuninist: json["Bakuninist"],
+        be: json["be"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chub: json["chub"],
+        cuprosilicon: json["cuprosilicon"],
+        curtailedly: json["curtailedly"],
+        dellenite: json["dellenite"],
+        dimitry: json["Dimitry"],
+        disdiapason: json["disdiapason"],
+        edifying: json["edifying"],
+        ethmoiditis: json["ethmoiditis"],
+        gastralgy: json["gastralgy"],
+        goatherd: json["goatherd"],
+        hammerdress: json["hammerdress"],
+        hangfire: json["hangfire"],
+        homocerc: json["homocerc"],
+        lacunosity: json["lacunosity"],
+        longiloquence: json["longiloquence"],
+        mameliere: json["mameliere"],
+        motherless: json["motherless"],
+        nonbookish: json["nonbookish"],
+        noncorrodible: json["noncorrodible"],
+        nonsensicality: json["nonsensicality"],
+        oafishly: json["oafishly"],
+        pfund: json["pfund"],
+        preadvisory: json["preadvisory"],
+        retroflexed: json["retroflexed"],
+        saccharulmic: json["saccharulmic"],
+        scowlful: json["scowlful"],
+        secluded: json["secluded"],
+        slackage: json["slackage"],
+        sphaeridial: json["sphaeridial"],
+        spondulics: json["spondulics"],
+        subsecive: json["subsecive"],
+        swellmobsman: json["swellmobsman"],
+        trachyglossate: json["trachyglossate"],
+        trialogue: json["trialogue"],
+        unassuaged: json["unassuaged"],
+        ungross: json["ungross"],
+        unjudiciously: json["unjudiciously"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Alicant": alicant,
+        "antiatonement": antiatonement,
+        "anticorrosive": anticorrosive,
+        "aphidozer": aphidozer,
+        "Bakuninist": bakuninist,
+        "be": be,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "chub": chub,
+        "cuprosilicon": cuprosilicon,
+        "curtailedly": curtailedly,
+        "dellenite": dellenite,
+        "Dimitry": dimitry,
+        "disdiapason": disdiapason,
+        "edifying": edifying,
+        "ethmoiditis": ethmoiditis,
+        "gastralgy": gastralgy,
+        "goatherd": goatherd,
+        "hammerdress": hammerdress,
+        "hangfire": hangfire,
+        "homocerc": homocerc,
+        "lacunosity": lacunosity,
+        "longiloquence": longiloquence,
+        "mameliere": mameliere,
+        "motherless": motherless,
+        "nonbookish": nonbookish,
+        "noncorrodible": noncorrodible,
+        "nonsensicality": nonsensicality,
+        "oafishly": oafishly,
+        "pfund": pfund,
+        "preadvisory": preadvisory,
+        "retroflexed": retroflexed,
+        "saccharulmic": saccharulmic,
+        "scowlful": scowlful,
+        "secluded": secluded,
+        "slackage": slackage,
+        "sphaeridial": sphaeridial,
+        "spondulics": spondulics,
+        "subsecive": subsecive,
+        "swellmobsman": swellmobsman,
+        "trachyglossate": trachyglossate,
+        "trialogue": trialogue,
+        "unassuaged": unassuaged,
+        "ungross": ungross,
+        "unjudiciously": unjudiciously,
+    };
+}
+
+class MonaziteClass {
+    final double catharticalness;
+    final int chirotherium;
+    final String disdiapason;
+    final bool homocerc;
+    final dynamic nonbookish;
+
+    MonaziteClass({
+        required this.catharticalness,
+        required this.chirotherium,
+        required this.disdiapason,
+        required this.homocerc,
+        required this.nonbookish,
+    });
+
+    factory MonaziteClass.fromJson(Map<String, dynamic> json) => MonaziteClass(
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        homocerc: json["homocerc"],
+        nonbookish: json["nonbookish"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "homocerc": homocerc,
+        "nonbookish": nonbookish,
+    };
+}
+
+class MonotheisticallyClass {
+    final dynamic blaspheme;
+    final double? catharticalness;
+    final dynamic celiosalpingectomy;
+    final int? chirotherium;
+    final dynamic consummativeness;
+    final String? disdiapason;
+    final dynamic egestive;
+    final dynamic enchylema;
+    final dynamic gasconade;
+    final dynamic holidayer;
+    final bool? homocerc;
+    final dynamic intuitionalism;
+    final dynamic lophiostomate;
+    final dynamic nonbookish;
+    final dynamic nonvolition;
+    final dynamic palatableness;
+    final dynamic pimpery;
+    final dynamic previolation;
+    final dynamic reconveyance;
+    final dynamic registership;
+    final dynamic rhyacolite;
+    final dynamic smithereens;
+    final dynamic superedification;
+    final dynamic trust;
+    final dynamic whitestone;
+
+    MonotheisticallyClass({
+        this.blaspheme,
+        this.catharticalness,
+        this.celiosalpingectomy,
+        this.chirotherium,
+        this.consummativeness,
+        this.disdiapason,
+        this.egestive,
+        this.enchylema,
+        this.gasconade,
+        this.holidayer,
+        this.homocerc,
+        this.intuitionalism,
+        this.lophiostomate,
+        this.nonbookish,
+        this.nonvolition,
+        this.palatableness,
+        this.pimpery,
+        this.previolation,
+        this.reconveyance,
+        this.registership,
+        this.rhyacolite,
+        this.smithereens,
+        this.superedification,
+        this.trust,
+        this.whitestone,
+    });
+
+    factory MonotheisticallyClass.fromJson(Map<String, dynamic> json) => MonotheisticallyClass(
+        blaspheme: json["blaspheme"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        celiosalpingectomy: json["celiosalpingectomy"],
+        chirotherium: json["Chirotherium"],
+        consummativeness: json["consummativeness"],
+        disdiapason: json["disdiapason"],
+        egestive: json["egestive"],
+        enchylema: json["enchylema"],
+        gasconade: json["gasconade"],
+        holidayer: json["holidayer"],
+        homocerc: json["homocerc"],
+        intuitionalism: json["intuitionalism"],
+        lophiostomate: json["lophiostomate"],
+        nonbookish: json["nonbookish"],
+        nonvolition: json["nonvolition"],
+        palatableness: json["palatableness"],
+        pimpery: json["pimpery"],
+        previolation: json["previolation"],
+        reconveyance: json["reconveyance"],
+        registership: json["registership"],
+        rhyacolite: json["rhyacolite"],
+        smithereens: json["smithereens"],
+        superedification: json["superedification"],
+        trust: json["trust"],
+        whitestone: json["whitestone"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "blaspheme": blaspheme,
+        "catharticalness": catharticalness,
+        "celiosalpingectomy": celiosalpingectomy,
+        "Chirotherium": chirotherium,
+        "consummativeness": consummativeness,
+        "disdiapason": disdiapason,
+        "egestive": egestive,
+        "enchylema": enchylema,
+        "gasconade": gasconade,
+        "holidayer": holidayer,
+        "homocerc": homocerc,
+        "intuitionalism": intuitionalism,
+        "lophiostomate": lophiostomate,
+        "nonbookish": nonbookish,
+        "nonvolition": nonvolition,
+        "palatableness": palatableness,
+        "pimpery": pimpery,
+        "previolation": previolation,
+        "reconveyance": reconveyance,
+        "registership": registership,
+        "rhyacolite": rhyacolite,
+        "smithereens": smithereens,
+        "superedification": superedification,
+        "trust": trust,
+        "whitestone": whitestone,
+    };
+}
+
+class Noncontributing {
+    final String estevin;
+    final double jolterhead;
+    final int sauternes;
+    final bool sparsely;
+    final dynamic unrequested;
+
+    Noncontributing({
+        required this.estevin,
+        required this.jolterhead,
+        required this.sauternes,
+        required this.sparsely,
+        required this.unrequested,
+    });
+
+    factory Noncontributing.fromJson(Map<String, dynamic> json) => Noncontributing(
+        estevin: json["estevin"],
+        jolterhead: json["jolterhead"]?.toDouble(),
+        sauternes: json["sauternes"],
+        sparsely: json["sparsely"],
+        unrequested: json["unrequested"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "estevin": estevin,
+        "jolterhead": jolterhead,
+        "sauternes": sauternes,
+        "sparsely": sparsely,
+        "unrequested": unrequested,
+    };
+}
+
+class OccupationalistClass {
+    final dynamic beholdable;
+    final dynamic brotuliform;
+    final dynamic chimakum;
+    final dynamic doodler;
+    final dynamic emulsin;
+    final dynamic fin;
+    final dynamic flourishing;
+    final dynamic flueless;
+    final dynamic furtively;
+    final dynamic gritter;
+    final dynamic interwish;
+    final dynamic monoxylic;
+    final dynamic myristic;
+    final dynamic nightwear;
+    final dynamic peruser;
+    final dynamic theoastrological;
+    final dynamic thumby;
+    final dynamic tingitid;
+    final dynamic trailless;
+    final dynamic unpocketed;
+
+    OccupationalistClass({
+        required this.beholdable,
+        required this.brotuliform,
+        required this.chimakum,
+        required this.doodler,
+        required this.emulsin,
+        required this.fin,
+        required this.flourishing,
+        required this.flueless,
+        required this.furtively,
+        required this.gritter,
+        required this.interwish,
+        required this.monoxylic,
+        required this.myristic,
+        required this.nightwear,
+        required this.peruser,
+        required this.theoastrological,
+        required this.thumby,
+        required this.tingitid,
+        required this.trailless,
+        required this.unpocketed,
+    });
+
+    factory OccupationalistClass.fromJson(Map<String, dynamic> json) => OccupationalistClass(
+        beholdable: json["beholdable"],
+        brotuliform: json["brotuliform"],
+        chimakum: json["Chimakum"],
+        doodler: json["doodler"],
+        emulsin: json["emulsin"],
+        fin: json["Fin"],
+        flourishing: json["flourishing"],
+        flueless: json["flueless"],
+        furtively: json["furtively"],
+        gritter: json["gritter"],
+        interwish: json["interwish"],
+        monoxylic: json["monoxylic"],
+        myristic: json["myristic"],
+        nightwear: json["nightwear"],
+        peruser: json["peruser"],
+        theoastrological: json["theoastrological"],
+        thumby: json["thumby"],
+        tingitid: json["tingitid"],
+        trailless: json["trailless"],
+        unpocketed: json["unpocketed"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "beholdable": beholdable,
+        "brotuliform": brotuliform,
+        "Chimakum": chimakum,
+        "doodler": doodler,
+        "emulsin": emulsin,
+        "Fin": fin,
+        "flourishing": flourishing,
+        "flueless": flueless,
+        "furtively": furtively,
+        "gritter": gritter,
+        "interwish": interwish,
+        "monoxylic": monoxylic,
+        "myristic": myristic,
+        "nightwear": nightwear,
+        "peruser": peruser,
+        "theoastrological": theoastrological,
+        "thumby": thumby,
+        "tingitid": tingitid,
+        "trailless": trailless,
+        "unpocketed": unpocketed,
+    };
+}
+
+class OutrivalClass {
+    final dynamic adroitly;
+    final dynamic bridehood;
+    final dynamic castoroides;
+    final dynamic czechoslovak;
+    final dynamic diagenesis;
+    final dynamic dihexahedron;
+    final dynamic dopester;
+    final dynamic eumerism;
+    final dynamic flyness;
+    final dynamic fouler;
+    final dynamic laudanosine;
+    final dynamic lingulidae;
+    final dynamic minutary;
+    final dynamic mitra;
+    final dynamic opisthorchiasis;
+    final dynamic pensively;
+    final dynamic pubigerous;
+    final dynamic rebellious;
+    final dynamic recodify;
+    final dynamic unpaced;
+
+    OutrivalClass({
+        required this.adroitly,
+        required this.bridehood,
+        required this.castoroides,
+        required this.czechoslovak,
+        required this.diagenesis,
+        required this.dihexahedron,
+        required this.dopester,
+        required this.eumerism,
+        required this.flyness,
+        required this.fouler,
+        required this.laudanosine,
+        required this.lingulidae,
+        required this.minutary,
+        required this.mitra,
+        required this.opisthorchiasis,
+        required this.pensively,
+        required this.pubigerous,
+        required this.rebellious,
+        required this.recodify,
+        required this.unpaced,
+    });
+
+    factory OutrivalClass.fromJson(Map<String, dynamic> json) => OutrivalClass(
+        adroitly: json["adroitly"],
+        bridehood: json["bridehood"],
+        castoroides: json["Castoroides"],
+        czechoslovak: json["Czechoslovak"],
+        diagenesis: json["diagenesis"],
+        dihexahedron: json["dihexahedron"],
+        dopester: json["dopester"],
+        eumerism: json["eumerism"],
+        flyness: json["flyness"],
+        fouler: json["fouler"],
+        laudanosine: json["laudanosine"],
+        lingulidae: json["Lingulidae"],
+        minutary: json["minutary"],
+        mitra: json["mitra"],
+        opisthorchiasis: json["opisthorchiasis"],
+        pensively: json["pensively"],
+        pubigerous: json["pubigerous"],
+        rebellious: json["rebellious"],
+        recodify: json["recodify"],
+        unpaced: json["unpaced"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "adroitly": adroitly,
+        "bridehood": bridehood,
+        "Castoroides": castoroides,
+        "Czechoslovak": czechoslovak,
+        "diagenesis": diagenesis,
+        "dihexahedron": dihexahedron,
+        "dopester": dopester,
+        "eumerism": eumerism,
+        "flyness": flyness,
+        "fouler": fouler,
+        "laudanosine": laudanosine,
+        "Lingulidae": lingulidae,
+        "minutary": minutary,
+        "mitra": mitra,
+        "opisthorchiasis": opisthorchiasis,
+        "pensively": pensively,
+        "pubigerous": pubigerous,
+        "rebellious": rebellious,
+        "recodify": recodify,
+        "unpaced": unpaced,
+    };
+}
+
+class PiaculumClass {
+    final int? alada;
+    final int? amphistomous;
+    final int? boysenberry;
+    final double? catharticalness;
+    final int? chirotherium;
+    final int? decardinalize;
+    final int? discouragement;
+    final String? disdiapason;
+    final int? doitrified;
+    final int? hexaspermous;
+    final bool? homocerc;
+    final int? insinking;
+    final int? loathfulness;
+    final int? miasmatical;
+    final int? neurofibril;
+    final dynamic nonbookish;
+    final int? phonendoscope;
+    final int? pilferment;
+    final int? predismissory;
+    final int? preinscription;
+    final int? quotative;
+    final int? sienna;
+    final int? thorax;
+    final int? yachting;
+    final int? zipper;
+
+    PiaculumClass({
+        this.alada,
+        this.amphistomous,
+        this.boysenberry,
+        this.catharticalness,
+        this.chirotherium,
+        this.decardinalize,
+        this.discouragement,
+        this.disdiapason,
+        this.doitrified,
+        this.hexaspermous,
+        this.homocerc,
+        this.insinking,
+        this.loathfulness,
+        this.miasmatical,
+        this.neurofibril,
+        this.nonbookish,
+        this.phonendoscope,
+        this.pilferment,
+        this.predismissory,
+        this.preinscription,
+        this.quotative,
+        this.sienna,
+        this.thorax,
+        this.yachting,
+        this.zipper,
+    });
+
+    factory PiaculumClass.fromJson(Map<String, dynamic> json) => PiaculumClass(
+        alada: json["alada"],
+        amphistomous: json["amphistomous"],
+        boysenberry: json["boysenberry"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        decardinalize: json["decardinalize"],
+        discouragement: json["discouragement"],
+        disdiapason: json["disdiapason"],
+        doitrified: json["doitrified"],
+        hexaspermous: json["hexaspermous"],
+        homocerc: json["homocerc"],
+        insinking: json["insinking"],
+        loathfulness: json["loathfulness"],
+        miasmatical: json["miasmatical"],
+        neurofibril: json["neurofibril"],
+        nonbookish: json["nonbookish"],
+        phonendoscope: json["phonendoscope"],
+        pilferment: json["pilferment"],
+        predismissory: json["predismissory"],
+        preinscription: json["preinscription"],
+        quotative: json["quotative"],
+        sienna: json["sienna"],
+        thorax: json["thorax"],
+        yachting: json["yachting"],
+        zipper: json["Zipper"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "alada": alada,
+        "amphistomous": amphistomous,
+        "boysenberry": boysenberry,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "decardinalize": decardinalize,
+        "discouragement": discouragement,
+        "disdiapason": disdiapason,
+        "doitrified": doitrified,
+        "hexaspermous": hexaspermous,
+        "homocerc": homocerc,
+        "insinking": insinking,
+        "loathfulness": loathfulness,
+        "miasmatical": miasmatical,
+        "neurofibril": neurofibril,
+        "nonbookish": nonbookish,
+        "phonendoscope": phonendoscope,
+        "pilferment": pilferment,
+        "predismissory": predismissory,
+        "preinscription": preinscription,
+        "quotative": quotative,
+        "sienna": sienna,
+        "thorax": thorax,
+        "yachting": yachting,
+        "Zipper": zipper,
+    };
+}
+
+class Pneumocele {
+    final dynamic carbonarism;
+    final double? catharticalness;
+    final int? chirotherium;
+    final dynamic cineolic;
+    final dynamic cobbly;
+    final dynamic conchyliferous;
+    final dynamic congregation;
+    final String? disdiapason;
+    final dynamic enterotomy;
+    final dynamic entophytal;
+    final dynamic fewtrils;
+    final dynamic herem;
+    final bool? homocerc;
+    final dynamic koniga;
+    final dynamic meticulosity;
+    final dynamic micky;
+    final dynamic mismarriage;
+    final dynamic neurotrophic;
+    final dynamic nonbookish;
+    final dynamic persuasively;
+    final dynamic replaceable;
+    final dynamic silex;
+    final dynamic taillight;
+    final dynamic unjealous;
+    final dynamic visitorial;
+
+    Pneumocele({
+        this.carbonarism,
+        this.catharticalness,
+        this.chirotherium,
+        this.cineolic,
+        this.cobbly,
+        this.conchyliferous,
+        this.congregation,
+        this.disdiapason,
+        this.enterotomy,
+        this.entophytal,
+        this.fewtrils,
+        this.herem,
+        this.homocerc,
+        this.koniga,
+        this.meticulosity,
+        this.micky,
+        this.mismarriage,
+        this.neurotrophic,
+        this.nonbookish,
+        this.persuasively,
+        this.replaceable,
+        this.silex,
+        this.taillight,
+        this.unjealous,
+        this.visitorial,
+    });
+
+    factory Pneumocele.fromJson(Map<String, dynamic> json) => Pneumocele(
+        carbonarism: json["Carbonarism"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        cineolic: json["cineolic"],
+        cobbly: json["cobbly"],
+        conchyliferous: json["conchyliferous"],
+        congregation: json["congregation"],
+        disdiapason: json["disdiapason"],
+        enterotomy: json["enterotomy"],
+        entophytal: json["entophytal"],
+        fewtrils: json["fewtrils"],
+        herem: json["herem"],
+        homocerc: json["homocerc"],
+        koniga: json["Koniga"],
+        meticulosity: json["meticulosity"],
+        micky: json["Micky"],
+        mismarriage: json["mismarriage"],
+        neurotrophic: json["neurotrophic"],
+        nonbookish: json["nonbookish"],
+        persuasively: json["persuasively"],
+        replaceable: json["replaceable"],
+        silex: json["silex"],
+        taillight: json["taillight"],
+        unjealous: json["unjealous"],
+        visitorial: json["visitorial"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Carbonarism": carbonarism,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "cineolic": cineolic,
+        "cobbly": cobbly,
+        "conchyliferous": conchyliferous,
+        "congregation": congregation,
+        "disdiapason": disdiapason,
+        "enterotomy": enterotomy,
+        "entophytal": entophytal,
+        "fewtrils": fewtrils,
+        "herem": herem,
+        "homocerc": homocerc,
+        "Koniga": koniga,
+        "meticulosity": meticulosity,
+        "Micky": micky,
+        "mismarriage": mismarriage,
+        "neurotrophic": neurotrophic,
+        "nonbookish": nonbookish,
+        "persuasively": persuasively,
+        "replaceable": replaceable,
+        "silex": silex,
+        "taillight": taillight,
+        "unjealous": unjealous,
+        "visitorial": visitorial,
+    };
+}
+
+class PotwhiskyClass {
+    final dynamic arciform;
+    final dynamic cresolin;
+    final dynamic disheartener;
+    final dynamic disproportionable;
+    final dynamic euchorda;
+    final dynamic ferryway;
+    final dynamic filamentiferous;
+    final dynamic flemish;
+    final dynamic forgainst;
+    final dynamic grainering;
+    final dynamic irrevoluble;
+    final dynamic kindredship;
+    final dynamic pinguitudinous;
+    final dynamic simpletonic;
+    final dynamic singsong;
+    final dynamic submergement;
+    final dynamic supraoesophagal;
+    final dynamic thrashel;
+    final dynamic tyremesis;
+    final dynamic yoruba;
+
+    PotwhiskyClass({
+        required this.arciform,
+        required this.cresolin,
+        required this.disheartener,
+        required this.disproportionable,
+        required this.euchorda,
+        required this.ferryway,
+        required this.filamentiferous,
+        required this.flemish,
+        required this.forgainst,
+        required this.grainering,
+        required this.irrevoluble,
+        required this.kindredship,
+        required this.pinguitudinous,
+        required this.simpletonic,
+        required this.singsong,
+        required this.submergement,
+        required this.supraoesophagal,
+        required this.thrashel,
+        required this.tyremesis,
+        required this.yoruba,
+    });
+
+    factory PotwhiskyClass.fromJson(Map<String, dynamic> json) => PotwhiskyClass(
+        arciform: json["arciform"],
+        cresolin: json["cresolin"],
+        disheartener: json["disheartener"],
+        disproportionable: json["disproportionable"],
+        euchorda: json["Euchorda"],
+        ferryway: json["ferryway"],
+        filamentiferous: json["filamentiferous"],
+        flemish: json["flemish"],
+        forgainst: json["forgainst"],
+        grainering: json["grainering"],
+        irrevoluble: json["irrevoluble"],
+        kindredship: json["kindredship"],
+        pinguitudinous: json["pinguitudinous"],
+        simpletonic: json["simpletonic"],
+        singsong: json["singsong"],
+        submergement: json["submergement"],
+        supraoesophagal: json["supraoesophagal"],
+        thrashel: json["thrashel"],
+        tyremesis: json["tyremesis"],
+        yoruba: json["Yoruba"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "arciform": arciform,
+        "cresolin": cresolin,
+        "disheartener": disheartener,
+        "disproportionable": disproportionable,
+        "Euchorda": euchorda,
+        "ferryway": ferryway,
+        "filamentiferous": filamentiferous,
+        "flemish": flemish,
+        "forgainst": forgainst,
+        "grainering": grainering,
+        "irrevoluble": irrevoluble,
+        "kindredship": kindredship,
+        "pinguitudinous": pinguitudinous,
+        "simpletonic": simpletonic,
+        "singsong": singsong,
+        "submergement": submergement,
+        "supraoesophagal": supraoesophagal,
+        "thrashel": thrashel,
+        "tyremesis": tyremesis,
+        "Yoruba": yoruba,
+    };
+}
+
+class PrefreshmanClass {
+    final dynamic azorubine;
+    final dynamic choroiditis;
+    final dynamic coagulatory;
+    final dynamic cyclorama;
+    final dynamic dolphus;
+    final dynamic duckhearted;
+    final dynamic ficus;
+    final dynamic gemaric;
+    final dynamic jugation;
+    final dynamic myoliposis;
+    final dynamic nonnomination;
+    final dynamic palay;
+    final dynamic pentactinal;
+    final dynamic phaet;
+    final dynamic piquant;
+    final dynamic registration;
+    final dynamic remancipation;
+    final dynamic scutatiform;
+    final dynamic theodolite;
+    final dynamic underward;
+
+    PrefreshmanClass({
+        required this.azorubine,
+        required this.choroiditis,
+        required this.coagulatory,
+        required this.cyclorama,
+        required this.dolphus,
+        required this.duckhearted,
+        required this.ficus,
+        required this.gemaric,
+        required this.jugation,
+        required this.myoliposis,
+        required this.nonnomination,
+        required this.palay,
+        required this.pentactinal,
+        required this.phaet,
+        required this.piquant,
+        required this.registration,
+        required this.remancipation,
+        required this.scutatiform,
+        required this.theodolite,
+        required this.underward,
+    });
+
+    factory PrefreshmanClass.fromJson(Map<String, dynamic> json) => PrefreshmanClass(
+        azorubine: json["azorubine"],
+        choroiditis: json["choroiditis"],
+        coagulatory: json["coagulatory"],
+        cyclorama: json["cyclorama"],
+        dolphus: json["Dolphus"],
+        duckhearted: json["duckhearted"],
+        ficus: json["Ficus"],
+        gemaric: json["Gemaric"],
+        jugation: json["jugation"],
+        myoliposis: json["myoliposis"],
+        nonnomination: json["nonnomination"],
+        palay: json["palay"],
+        pentactinal: json["pentactinal"],
+        phaet: json["Phaet"],
+        piquant: json["piquant"],
+        registration: json["registration"],
+        remancipation: json["remancipation"],
+        scutatiform: json["scutatiform"],
+        theodolite: json["theodolite"],
+        underward: json["underward"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "azorubine": azorubine,
+        "choroiditis": choroiditis,
+        "coagulatory": coagulatory,
+        "cyclorama": cyclorama,
+        "Dolphus": dolphus,
+        "duckhearted": duckhearted,
+        "Ficus": ficus,
+        "Gemaric": gemaric,
+        "jugation": jugation,
+        "myoliposis": myoliposis,
+        "nonnomination": nonnomination,
+        "palay": palay,
+        "pentactinal": pentactinal,
+        "Phaet": phaet,
+        "piquant": piquant,
+        "registration": registration,
+        "remancipation": remancipation,
+        "scutatiform": scutatiform,
+        "theodolite": theodolite,
+        "underward": underward,
+    };
+}
diff --git a/head/dart/test/inputs/json/priority/combinations3.json/final-props-false--58a791807e0c/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations3.json/final-props-false--58a791807e0c/TopLevel.dart
new file mode 100644
index 0000000..e603106
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/combinations3.json/final-props-false--58a791807e0c/TopLevel.dart
@@ -0,0 +1,1537 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    List<dynamic> juror;
+    List<dynamic> kongoni;
+    List<dynamic> ladronism;
+    List<dynamic> landlubberly;
+    List<dynamic> listener;
+    List<dynamic> lupus;
+    List<Maslin> maslin;
+    List<dynamic> monazite;
+    List<dynamic> monoliteral;
+    List<dynamic> monotheistically;
+    List<dynamic> montage;
+    List<dynamic> moralness;
+    List<MonaziteClass?> mowra;
+    List<dynamic> mulishly;
+    List<dynamic> myoscope;
+    List<List<int?>?> nach;
+    List<dynamic> neuromastic;
+    List<Noncontributing> noncontributing;
+    List<dynamic> nonnervous;
+    List<dynamic> nonvaluation;
+    List<dynamic> occupationalist;
+    List<dynamic> outrival;
+    List<dynamic> paleographically;
+    List<dynamic> pamphletwise;
+    List<dynamic> pediatrics;
+    List<bool> perceptive;
+    List<dynamic> piaculum;
+    List<dynamic> piccadilly;
+    List<dynamic> piffler;
+    List<dynamic> pithful;
+    List<dynamic> placuntitis;
+    List<dynamic> plectopterous;
+    List<Pneumocele?> pneumocele;
+    List<dynamic> poliorcetic;
+    List<dynamic> poormaster;
+    List<dynamic> potwhisky;
+    List<dynamic> practicalizer;
+    List<dynamic> prefreshman;
+    List<dynamic> prehensility;
+    List<dynamic> prevoidance;
+    List<Map<String, int?>> probant;
+    List<dynamic> protext;
+
+    TopLevel({
+        required this.juror,
+        required this.kongoni,
+        required this.ladronism,
+        required this.landlubberly,
+        required this.listener,
+        required this.lupus,
+        required this.maslin,
+        required this.monazite,
+        required this.monoliteral,
+        required this.monotheistically,
+        required this.montage,
+        required this.moralness,
+        required this.mowra,
+        required this.mulishly,
+        required this.myoscope,
+        required this.nach,
+        required this.neuromastic,
+        required this.noncontributing,
+        required this.nonnervous,
+        required this.nonvaluation,
+        required this.occupationalist,
+        required this.outrival,
+        required this.paleographically,
+        required this.pamphletwise,
+        required this.pediatrics,
+        required this.perceptive,
+        required this.piaculum,
+        required this.piccadilly,
+        required this.piffler,
+        required this.pithful,
+        required this.placuntitis,
+        required this.plectopterous,
+        required this.pneumocele,
+        required this.poliorcetic,
+        required this.poormaster,
+        required this.potwhisky,
+        required this.practicalizer,
+        required this.prefreshman,
+        required this.prehensility,
+        required this.prevoidance,
+        required this.probant,
+        required this.protext,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        juror: List<dynamic>.from(json["juror"].map((x) => x)),
+        kongoni: List<dynamic>.from(json["kongoni"].map((x) => x)),
+        ladronism: List<dynamic>.from(json["ladronism"].map((x) => x)),
+        landlubberly: List<dynamic>.from(json["landlubberly"].map((x) => x)),
+        listener: List<dynamic>.from(json["listener"].map((x) => x)),
+        lupus: List<dynamic>.from(json["lupus"].map((x) => x)),
+        maslin: List<Maslin>.from(json["maslin"].map((x) => Maslin.fromJson(x))),
+        monazite: List<dynamic>.from(json["monazite"].map((x) => x)),
+        monoliteral: List<dynamic>.from(json["monoliteral"].map((x) => x)),
+        monotheistically: List<dynamic>.from(json["monotheistically"].map((x) => x)),
+        montage: List<dynamic>.from(json["montage"].map((x) => x)),
+        moralness: List<dynamic>.from(json["moralness"].map((x) => x)),
+        mowra: List<MonaziteClass?>.from(json["mowra"].map((x) => x == null ? null : MonaziteClass.fromJson(x))),
+        mulishly: List<dynamic>.from(json["mulishly"].map((x) => x)),
+        myoscope: List<dynamic>.from(json["myoscope"].map((x) => x)),
+        nach: List<List<int?>?>.from(json["nach"].map((x) => x == null ? null : List<int?>.from(x!.map((x) => x)))),
+        neuromastic: List<dynamic>.from(json["neuromastic"].map((x) => x)),
+        noncontributing: List<Noncontributing>.from(json["noncontributing"].map((x) => Noncontributing.fromJson(x))),
+        nonnervous: List<dynamic>.from(json["nonnervous"].map((x) => x)),
+        nonvaluation: List<dynamic>.from(json["nonvaluation"].map((x) => x)),
+        occupationalist: List<dynamic>.from(json["occupationalist"].map((x) => x)),
+        outrival: List<dynamic>.from(json["outrival"].map((x) => x)),
+        paleographically: List<dynamic>.from(json["paleographically"].map((x) => x)),
+        pamphletwise: List<dynamic>.from(json["pamphletwise"].map((x) => x)),
+        pediatrics: List<dynamic>.from(json["pediatrics"].map((x) => x)),
+        perceptive: List<bool>.from(json["perceptive"].map((x) => x)),
+        piaculum: List<dynamic>.from(json["piaculum"].map((x) => x)),
+        piccadilly: List<dynamic>.from(json["piccadilly"].map((x) => x)),
+        piffler: List<dynamic>.from(json["piffler"].map((x) => x)),
+        pithful: List<dynamic>.from(json["pithful"].map((x) => x)),
+        placuntitis: List<dynamic>.from(json["placuntitis"].map((x) => x)),
+        plectopterous: List<dynamic>.from(json["plectopterous"].map((x) => x)),
+        pneumocele: List<Pneumocele?>.from(json["pneumocele"].map((x) => x == null ? null : Pneumocele.fromJson(x))),
+        poliorcetic: List<dynamic>.from(json["poliorcetic"].map((x) => x)),
+        poormaster: List<dynamic>.from(json["poormaster"].map((x) => x)),
+        potwhisky: List<dynamic>.from(json["potwhisky"].map((x) => x)),
+        practicalizer: List<dynamic>.from(json["practicalizer"].map((x) => x)),
+        prefreshman: List<dynamic>.from(json["prefreshman"].map((x) => x)),
+        prehensility: List<dynamic>.from(json["prehensility"].map((x) => x)),
+        prevoidance: List<dynamic>.from(json["prevoidance"].map((x) => x)),
+        probant: List<Map<String, int?>>.from(json["probant"].map((x) => Map.from(x).map((k, v) => MapEntry<String, int?>(k, v)))),
+        protext: List<dynamic>.from(json["protext"].map((x) => x)),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "juror": List<dynamic>.from(juror.map((x) => x)),
+        "kongoni": List<dynamic>.from(kongoni.map((x) => x)),
+        "ladronism": List<dynamic>.from(ladronism.map((x) => x)),
+        "landlubberly": List<dynamic>.from(landlubberly.map((x) => x)),
+        "listener": List<dynamic>.from(listener.map((x) => x)),
+        "lupus": List<dynamic>.from(lupus.map((x) => x)),
+        "maslin": List<dynamic>.from(maslin.map((x) => x.toJson())),
+        "monazite": List<dynamic>.from(monazite.map((x) => x)),
+        "monoliteral": List<dynamic>.from(monoliteral.map((x) => x)),
+        "monotheistically": List<dynamic>.from(monotheistically.map((x) => x)),
+        "montage": List<dynamic>.from(montage.map((x) => x)),
+        "moralness": List<dynamic>.from(moralness.map((x) => x)),
+        "mowra": List<dynamic>.from(mowra.map((x) => x?.toJson())),
+        "mulishly": List<dynamic>.from(mulishly.map((x) => x)),
+        "myoscope": List<dynamic>.from(myoscope.map((x) => x)),
+        "nach": List<dynamic>.from(nach.map((x) => x == null ? null : List<dynamic>.from(x!.map((x) => x)))),
+        "neuromastic": List<dynamic>.from(neuromastic.map((x) => x)),
+        "noncontributing": List<dynamic>.from(noncontributing.map((x) => x.toJson())),
+        "nonnervous": List<dynamic>.from(nonnervous.map((x) => x)),
+        "nonvaluation": List<dynamic>.from(nonvaluation.map((x) => x)),
+        "occupationalist": List<dynamic>.from(occupationalist.map((x) => x)),
+        "outrival": List<dynamic>.from(outrival.map((x) => x)),
+        "paleographically": List<dynamic>.from(paleographically.map((x) => x)),
+        "pamphletwise": List<dynamic>.from(pamphletwise.map((x) => x)),
+        "pediatrics": List<dynamic>.from(pediatrics.map((x) => x)),
+        "perceptive": List<dynamic>.from(perceptive.map((x) => x)),
+        "piaculum": List<dynamic>.from(piaculum.map((x) => x)),
+        "piccadilly": List<dynamic>.from(piccadilly.map((x) => x)),
+        "piffler": List<dynamic>.from(piffler.map((x) => x)),
+        "pithful": List<dynamic>.from(pithful.map((x) => x)),
+        "placuntitis": List<dynamic>.from(placuntitis.map((x) => x)),
+        "plectopterous": List<dynamic>.from(plectopterous.map((x) => x)),
+        "pneumocele": List<dynamic>.from(pneumocele.map((x) => x?.toJson())),
+        "poliorcetic": List<dynamic>.from(poliorcetic.map((x) => x)),
+        "poormaster": List<dynamic>.from(poormaster.map((x) => x)),
+        "potwhisky": List<dynamic>.from(potwhisky.map((x) => x)),
+        "practicalizer": List<dynamic>.from(practicalizer.map((x) => x)),
+        "prefreshman": List<dynamic>.from(prefreshman.map((x) => x)),
+        "prehensility": List<dynamic>.from(prehensility.map((x) => x)),
+        "prevoidance": List<dynamic>.from(prevoidance.map((x) => x)),
+        "probant": List<dynamic>.from(probant.map((x) => Map.from(x).map((k, v) => MapEntry<String, dynamic>(k, v)))),
+        "protext": List<dynamic>.from(protext.map((x) => x)),
+    };
+}
+
+class JurorClass {
+    dynamic adipsy;
+    dynamic auxiliator;
+    dynamic benda;
+    dynamic benjamin;
+    dynamic brandling;
+    dynamic epicurishly;
+    dynamic eremochaetous;
+    dynamic marten;
+    dynamic monocline;
+    dynamic olea;
+    dynamic palgat;
+    dynamic pennyworth;
+    dynamic pioury;
+    dynamic pragmatistic;
+    dynamic stylelessness;
+    dynamic systematical;
+    dynamic thready;
+    dynamic uncontemporary;
+    dynamic uncouched;
+    dynamic uninhabitedness;
+
+    JurorClass({
+        required this.adipsy,
+        required this.auxiliator,
+        required this.benda,
+        required this.benjamin,
+        required this.brandling,
+        required this.epicurishly,
+        required this.eremochaetous,
+        required this.marten,
+        required this.monocline,
+        required this.olea,
+        required this.palgat,
+        required this.pennyworth,
+        required this.pioury,
+        required this.pragmatistic,
+        required this.stylelessness,
+        required this.systematical,
+        required this.thready,
+        required this.uncontemporary,
+        required this.uncouched,
+        required this.uninhabitedness,
+    });
+
+    factory JurorClass.fromJson(Map<String, dynamic> json) => JurorClass(
+        adipsy: json["adipsy"],
+        auxiliator: json["auxiliator"],
+        benda: json["benda"],
+        benjamin: json["benjamin"],
+        brandling: json["brandling"],
+        epicurishly: json["epicurishly"],
+        eremochaetous: json["eremochaetous"],
+        marten: json["marten"],
+        monocline: json["monocline"],
+        olea: json["Olea"],
+        palgat: json["palgat"],
+        pennyworth: json["pennyworth"],
+        pioury: json["pioury"],
+        pragmatistic: json["pragmatistic"],
+        stylelessness: json["stylelessness"],
+        systematical: json["systematical"],
+        thready: json["thready"],
+        uncontemporary: json["uncontemporary"],
+        uncouched: json["uncouched"],
+        uninhabitedness: json["uninhabitedness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "adipsy": adipsy,
+        "auxiliator": auxiliator,
+        "benda": benda,
+        "benjamin": benjamin,
+        "brandling": brandling,
+        "epicurishly": epicurishly,
+        "eremochaetous": eremochaetous,
+        "marten": marten,
+        "monocline": monocline,
+        "Olea": olea,
+        "palgat": palgat,
+        "pennyworth": pennyworth,
+        "pioury": pioury,
+        "pragmatistic": pragmatistic,
+        "stylelessness": stylelessness,
+        "systematical": systematical,
+        "thready": thready,
+        "uncontemporary": uncontemporary,
+        "uncouched": uncouched,
+        "uninhabitedness": uninhabitedness,
+    };
+}
+
+class LadronismClass {
+    dynamic acclaimer;
+    dynamic achree;
+    dynamic base;
+    dynamic conundrumize;
+    dynamic degerminator;
+    dynamic describable;
+    dynamic exasperatedly;
+    dynamic heroine;
+    dynamic indazin;
+    dynamic luteous;
+    dynamic papular;
+    dynamic pritch;
+    dynamic prodenia;
+    dynamic seege;
+    dynamic shopgirl;
+    dynamic tragedietta;
+    dynamic unsparse;
+    dynamic uplook;
+    dynamic vermiformis;
+    dynamic whafabout;
+
+    LadronismClass({
+        required this.acclaimer,
+        required this.achree,
+        required this.base,
+        required this.conundrumize,
+        required this.degerminator,
+        required this.describable,
+        required this.exasperatedly,
+        required this.heroine,
+        required this.indazin,
+        required this.luteous,
+        required this.papular,
+        required this.pritch,
+        required this.prodenia,
+        required this.seege,
+        required this.shopgirl,
+        required this.tragedietta,
+        required this.unsparse,
+        required this.uplook,
+        required this.vermiformis,
+        required this.whafabout,
+    });
+
+    factory LadronismClass.fromJson(Map<String, dynamic> json) => LadronismClass(
+        acclaimer: json["acclaimer"],
+        achree: json["achree"],
+        base: json["base"],
+        conundrumize: json["conundrumize"],
+        degerminator: json["degerminator"],
+        describable: json["describable"],
+        exasperatedly: json["exasperatedly"],
+        heroine: json["heroine"],
+        indazin: json["indazin"],
+        luteous: json["luteous"],
+        papular: json["papular"],
+        pritch: json["pritch"],
+        prodenia: json["Prodenia"],
+        seege: json["seege"],
+        shopgirl: json["shopgirl"],
+        tragedietta: json["tragedietta"],
+        unsparse: json["unsparse"],
+        uplook: json["uplook"],
+        vermiformis: json["vermiformis"],
+        whafabout: json["whafabout"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "acclaimer": acclaimer,
+        "achree": achree,
+        "base": base,
+        "conundrumize": conundrumize,
+        "degerminator": degerminator,
+        "describable": describable,
+        "exasperatedly": exasperatedly,
+        "heroine": heroine,
+        "indazin": indazin,
+        "luteous": luteous,
+        "papular": papular,
+        "pritch": pritch,
+        "Prodenia": prodenia,
+        "seege": seege,
+        "shopgirl": shopgirl,
+        "tragedietta": tragedietta,
+        "unsparse": unsparse,
+        "uplook": uplook,
+        "vermiformis": vermiformis,
+        "whafabout": whafabout,
+    };
+}
+
+class LandlubberlyClass {
+    dynamic acropoleis;
+    dynamic aminate;
+    dynamic amyraldism;
+    dynamic bipenniform;
+    dynamic bugre;
+    dynamic calycule;
+    dynamic caoutchouc;
+    dynamic disprover;
+    dynamic fitroot;
+    dynamic fulgently;
+    dynamic kickup;
+    dynamic laevoversion;
+    dynamic moter;
+    dynamic objectivity;
+    dynamic posterity;
+    dynamic postnuptial;
+    dynamic precedentary;
+    dynamic saddling;
+    dynamic subcurrent;
+    dynamic unrecriminative;
+
+    LandlubberlyClass({
+        required this.acropoleis,
+        required this.aminate,
+        required this.amyraldism,
+        required this.bipenniform,
+        required this.bugre,
+        required this.calycule,
+        required this.caoutchouc,
+        required this.disprover,
+        required this.fitroot,
+        required this.fulgently,
+        required this.kickup,
+        required this.laevoversion,
+        required this.moter,
+        required this.objectivity,
+        required this.posterity,
+        required this.postnuptial,
+        required this.precedentary,
+        required this.saddling,
+        required this.subcurrent,
+        required this.unrecriminative,
+    });
+
+    factory LandlubberlyClass.fromJson(Map<String, dynamic> json) => LandlubberlyClass(
+        acropoleis: json["acropoleis"],
+        aminate: json["aminate"],
+        amyraldism: json["Amyraldism"],
+        bipenniform: json["bipenniform"],
+        bugre: json["bugre"],
+        calycule: json["calycule"],
+        caoutchouc: json["caoutchouc"],
+        disprover: json["disprover"],
+        fitroot: json["fitroot"],
+        fulgently: json["fulgently"],
+        kickup: json["kickup"],
+        laevoversion: json["laevoversion"],
+        moter: json["moter"],
+        objectivity: json["objectivity"],
+        posterity: json["posterity"],
+        postnuptial: json["postnuptial"],
+        precedentary: json["precedentary"],
+        saddling: json["saddling"],
+        subcurrent: json["subcurrent"],
+        unrecriminative: json["unrecriminative"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "acropoleis": acropoleis,
+        "aminate": aminate,
+        "Amyraldism": amyraldism,
+        "bipenniform": bipenniform,
+        "bugre": bugre,
+        "calycule": calycule,
+        "caoutchouc": caoutchouc,
+        "disprover": disprover,
+        "fitroot": fitroot,
+        "fulgently": fulgently,
+        "kickup": kickup,
+        "laevoversion": laevoversion,
+        "moter": moter,
+        "objectivity": objectivity,
+        "posterity": posterity,
+        "postnuptial": postnuptial,
+        "precedentary": precedentary,
+        "saddling": saddling,
+        "subcurrent": subcurrent,
+        "unrecriminative": unrecriminative,
+    };
+}
+
+class LupusClass {
+    double? catharticalness;
+    int? chirotherium;
+    int? chlorioninae;
+    int? corvinae;
+    int? crassina;
+    String? disdiapason;
+    int? exiguity;
+    int? farcist;
+    int? holographical;
+    bool? homocerc;
+    int? ichthyophagan;
+    int? implacable;
+    dynamic nonbookish;
+    int? outshiner;
+    int? overweather;
+    int? protonegroid;
+    int? shallowish;
+    int? snoke;
+    int? snout;
+    int? surveillance;
+    int? threshingtime;
+    int? thysanocarpus;
+    int? unsignificantly;
+    int? unsnap;
+    int? vendible;
+
+    LupusClass({
+        this.catharticalness,
+        this.chirotherium,
+        this.chlorioninae,
+        this.corvinae,
+        this.crassina,
+        this.disdiapason,
+        this.exiguity,
+        this.farcist,
+        this.holographical,
+        this.homocerc,
+        this.ichthyophagan,
+        this.implacable,
+        this.nonbookish,
+        this.outshiner,
+        this.overweather,
+        this.protonegroid,
+        this.shallowish,
+        this.snoke,
+        this.snout,
+        this.surveillance,
+        this.threshingtime,
+        this.thysanocarpus,
+        this.unsignificantly,
+        this.unsnap,
+        this.vendible,
+    });
+
+    factory LupusClass.fromJson(Map<String, dynamic> json) => LupusClass(
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chlorioninae: json["Chlorioninae"],
+        corvinae: json["Corvinae"],
+        crassina: json["Crassina"],
+        disdiapason: json["disdiapason"],
+        exiguity: json["exiguity"],
+        farcist: json["farcist"],
+        holographical: json["holographical"],
+        homocerc: json["homocerc"],
+        ichthyophagan: json["ichthyophagan"],
+        implacable: json["implacable"],
+        nonbookish: json["nonbookish"],
+        outshiner: json["outshiner"],
+        overweather: json["overweather"],
+        protonegroid: json["protonegroid"],
+        shallowish: json["shallowish"],
+        snoke: json["snoke"],
+        snout: json["snout"],
+        surveillance: json["surveillance"],
+        threshingtime: json["threshingtime"],
+        thysanocarpus: json["Thysanocarpus"],
+        unsignificantly: json["unsignificantly"],
+        unsnap: json["unsnap"],
+        vendible: json["vendible"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "Chlorioninae": chlorioninae,
+        "Corvinae": corvinae,
+        "Crassina": crassina,
+        "disdiapason": disdiapason,
+        "exiguity": exiguity,
+        "farcist": farcist,
+        "holographical": holographical,
+        "homocerc": homocerc,
+        "ichthyophagan": ichthyophagan,
+        "implacable": implacable,
+        "nonbookish": nonbookish,
+        "outshiner": outshiner,
+        "overweather": overweather,
+        "protonegroid": protonegroid,
+        "shallowish": shallowish,
+        "snoke": snoke,
+        "snout": snout,
+        "surveillance": surveillance,
+        "threshingtime": threshingtime,
+        "Thysanocarpus": thysanocarpus,
+        "unsignificantly": unsignificantly,
+        "unsnap": unsnap,
+        "vendible": vendible,
+    };
+}
+
+class Maslin {
+    int? alicant;
+    dynamic antiatonement;
+    int? anticorrosive;
+    dynamic aphidozer;
+    dynamic bakuninist;
+    int? be;
+    double? catharticalness;
+    int? chirotherium;
+    int? chub;
+    int? cuprosilicon;
+    int? curtailedly;
+    int? dellenite;
+    int? dimitry;
+    String? disdiapason;
+    dynamic edifying;
+    int? ethmoiditis;
+    dynamic gastralgy;
+    int? goatherd;
+    int? hammerdress;
+    dynamic hangfire;
+    bool? homocerc;
+    int? lacunosity;
+    dynamic longiloquence;
+    int? mameliere;
+    dynamic motherless;
+    dynamic nonbookish;
+    dynamic noncorrodible;
+    dynamic nonsensicality;
+    int? oafishly;
+    dynamic pfund;
+    dynamic preadvisory;
+    dynamic retroflexed;
+    int? saccharulmic;
+    int? scowlful;
+    dynamic secluded;
+    dynamic slackage;
+    int? sphaeridial;
+    dynamic spondulics;
+    int? subsecive;
+    dynamic swellmobsman;
+    int? trachyglossate;
+    dynamic trialogue;
+    int? unassuaged;
+    dynamic ungross;
+    dynamic unjudiciously;
+
+    Maslin({
+        this.alicant,
+        this.antiatonement,
+        this.anticorrosive,
+        this.aphidozer,
+        this.bakuninist,
+        this.be,
+        this.catharticalness,
+        this.chirotherium,
+        this.chub,
+        this.cuprosilicon,
+        this.curtailedly,
+        this.dellenite,
+        this.dimitry,
+        this.disdiapason,
+        this.edifying,
+        this.ethmoiditis,
+        this.gastralgy,
+        this.goatherd,
+        this.hammerdress,
+        this.hangfire,
+        this.homocerc,
+        this.lacunosity,
+        this.longiloquence,
+        this.mameliere,
+        this.motherless,
+        this.nonbookish,
+        this.noncorrodible,
+        this.nonsensicality,
+        this.oafishly,
+        this.pfund,
+        this.preadvisory,
+        this.retroflexed,
+        this.saccharulmic,
+        this.scowlful,
+        this.secluded,
+        this.slackage,
+        this.sphaeridial,
+        this.spondulics,
+        this.subsecive,
+        this.swellmobsman,
+        this.trachyglossate,
+        this.trialogue,
+        this.unassuaged,
+        this.ungross,
+        this.unjudiciously,
+    });
+
+    factory Maslin.fromJson(Map<String, dynamic> json) => Maslin(
+        alicant: json["Alicant"],
+        antiatonement: json["antiatonement"],
+        anticorrosive: json["anticorrosive"],
+        aphidozer: json["aphidozer"],
+        bakuninist: json["Bakuninist"],
+        be: json["be"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chub: json["chub"],
+        cuprosilicon: json["cuprosilicon"],
+        curtailedly: json["curtailedly"],
+        dellenite: json["dellenite"],
+        dimitry: json["Dimitry"],
+        disdiapason: json["disdiapason"],
+        edifying: json["edifying"],
+        ethmoiditis: json["ethmoiditis"],
+        gastralgy: json["gastralgy"],
+        goatherd: json["goatherd"],
+        hammerdress: json["hammerdress"],
+        hangfire: json["hangfire"],
+        homocerc: json["homocerc"],
+        lacunosity: json["lacunosity"],
+        longiloquence: json["longiloquence"],
+        mameliere: json["mameliere"],
+        motherless: json["motherless"],
+        nonbookish: json["nonbookish"],
+        noncorrodible: json["noncorrodible"],
+        nonsensicality: json["nonsensicality"],
+        oafishly: json["oafishly"],
+        pfund: json["pfund"],
+        preadvisory: json["preadvisory"],
+        retroflexed: json["retroflexed"],
+        saccharulmic: json["saccharulmic"],
+        scowlful: json["scowlful"],
+        secluded: json["secluded"],
+        slackage: json["slackage"],
+        sphaeridial: json["sphaeridial"],
+        spondulics: json["spondulics"],
+        subsecive: json["subsecive"],
+        swellmobsman: json["swellmobsman"],
+        trachyglossate: json["trachyglossate"],
+        trialogue: json["trialogue"],
+        unassuaged: json["unassuaged"],
+        ungross: json["ungross"],
+        unjudiciously: json["unjudiciously"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Alicant": alicant,
+        "antiatonement": antiatonement,
+        "anticorrosive": anticorrosive,
+        "aphidozer": aphidozer,
+        "Bakuninist": bakuninist,
+        "be": be,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "chub": chub,
+        "cuprosilicon": cuprosilicon,
+        "curtailedly": curtailedly,
+        "dellenite": dellenite,
+        "Dimitry": dimitry,
+        "disdiapason": disdiapason,
+        "edifying": edifying,
+        "ethmoiditis": ethmoiditis,
+        "gastralgy": gastralgy,
+        "goatherd": goatherd,
+        "hammerdress": hammerdress,
+        "hangfire": hangfire,
+        "homocerc": homocerc,
+        "lacunosity": lacunosity,
+        "longiloquence": longiloquence,
+        "mameliere": mameliere,
+        "motherless": motherless,
+        "nonbookish": nonbookish,
+        "noncorrodible": noncorrodible,
+        "nonsensicality": nonsensicality,
+        "oafishly": oafishly,
+        "pfund": pfund,
+        "preadvisory": preadvisory,
+        "retroflexed": retroflexed,
+        "saccharulmic": saccharulmic,
+        "scowlful": scowlful,
+        "secluded": secluded,
+        "slackage": slackage,
+        "sphaeridial": sphaeridial,
+        "spondulics": spondulics,
+        "subsecive": subsecive,
+        "swellmobsman": swellmobsman,
+        "trachyglossate": trachyglossate,
+        "trialogue": trialogue,
+        "unassuaged": unassuaged,
+        "ungross": ungross,
+        "unjudiciously": unjudiciously,
+    };
+}
+
+class MonaziteClass {
+    double catharticalness;
+    int chirotherium;
+    String disdiapason;
+    bool homocerc;
+    dynamic nonbookish;
+
+    MonaziteClass({
+        required this.catharticalness,
+        required this.chirotherium,
+        required this.disdiapason,
+        required this.homocerc,
+        required this.nonbookish,
+    });
+
+    factory MonaziteClass.fromJson(Map<String, dynamic> json) => MonaziteClass(
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        homocerc: json["homocerc"],
+        nonbookish: json["nonbookish"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "homocerc": homocerc,
+        "nonbookish": nonbookish,
+    };
+}
+
+class MonotheisticallyClass {
+    dynamic blaspheme;
+    double? catharticalness;
+    dynamic celiosalpingectomy;
+    int? chirotherium;
+    dynamic consummativeness;
+    String? disdiapason;
+    dynamic egestive;
+    dynamic enchylema;
+    dynamic gasconade;
+    dynamic holidayer;
+    bool? homocerc;
+    dynamic intuitionalism;
+    dynamic lophiostomate;
+    dynamic nonbookish;
+    dynamic nonvolition;
+    dynamic palatableness;
+    dynamic pimpery;
+    dynamic previolation;
+    dynamic reconveyance;
+    dynamic registership;
+    dynamic rhyacolite;
+    dynamic smithereens;
+    dynamic superedification;
+    dynamic trust;
+    dynamic whitestone;
+
+    MonotheisticallyClass({
+        this.blaspheme,
+        this.catharticalness,
+        this.celiosalpingectomy,
+        this.chirotherium,
+        this.consummativeness,
+        this.disdiapason,
+        this.egestive,
+        this.enchylema,
+        this.gasconade,
+        this.holidayer,
+        this.homocerc,
+        this.intuitionalism,
+        this.lophiostomate,
+        this.nonbookish,
+        this.nonvolition,
+        this.palatableness,
+        this.pimpery,
+        this.previolation,
+        this.reconveyance,
+        this.registership,
+        this.rhyacolite,
+        this.smithereens,
+        this.superedification,
+        this.trust,
+        this.whitestone,
+    });
+
+    factory MonotheisticallyClass.fromJson(Map<String, dynamic> json) => MonotheisticallyClass(
+        blaspheme: json["blaspheme"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        celiosalpingectomy: json["celiosalpingectomy"],
+        chirotherium: json["Chirotherium"],
+        consummativeness: json["consummativeness"],
+        disdiapason: json["disdiapason"],
+        egestive: json["egestive"],
+        enchylema: json["enchylema"],
+        gasconade: json["gasconade"],
+        holidayer: json["holidayer"],
+        homocerc: json["homocerc"],
+        intuitionalism: json["intuitionalism"],
+        lophiostomate: json["lophiostomate"],
+        nonbookish: json["nonbookish"],
+        nonvolition: json["nonvolition"],
+        palatableness: json["palatableness"],
+        pimpery: json["pimpery"],
+        previolation: json["previolation"],
+        reconveyance: json["reconveyance"],
+        registership: json["registership"],
+        rhyacolite: json["rhyacolite"],
+        smithereens: json["smithereens"],
+        superedification: json["superedification"],
+        trust: json["trust"],
+        whitestone: json["whitestone"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "blaspheme": blaspheme,
+        "catharticalness": catharticalness,
+        "celiosalpingectomy": celiosalpingectomy,
+        "Chirotherium": chirotherium,
+        "consummativeness": consummativeness,
+        "disdiapason": disdiapason,
+        "egestive": egestive,
+        "enchylema": enchylema,
+        "gasconade": gasconade,
+        "holidayer": holidayer,
+        "homocerc": homocerc,
+        "intuitionalism": intuitionalism,
+        "lophiostomate": lophiostomate,
+        "nonbookish": nonbookish,
+        "nonvolition": nonvolition,
+        "palatableness": palatableness,
+        "pimpery": pimpery,
+        "previolation": previolation,
+        "reconveyance": reconveyance,
+        "registership": registership,
+        "rhyacolite": rhyacolite,
+        "smithereens": smithereens,
+        "superedification": superedification,
+        "trust": trust,
+        "whitestone": whitestone,
+    };
+}
+
+class Noncontributing {
+    String estevin;
+    double jolterhead;
+    int sauternes;
+    bool sparsely;
+    dynamic unrequested;
+
+    Noncontributing({
+        required this.estevin,
+        required this.jolterhead,
+        required this.sauternes,
+        required this.sparsely,
+        required this.unrequested,
+    });
+
+    factory Noncontributing.fromJson(Map<String, dynamic> json) => Noncontributing(
+        estevin: json["estevin"],
+        jolterhead: json["jolterhead"]?.toDouble(),
+        sauternes: json["sauternes"],
+        sparsely: json["sparsely"],
+        unrequested: json["unrequested"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "estevin": estevin,
+        "jolterhead": jolterhead,
+        "sauternes": sauternes,
+        "sparsely": sparsely,
+        "unrequested": unrequested,
+    };
+}
+
+class OccupationalistClass {
+    dynamic beholdable;
+    dynamic brotuliform;
+    dynamic chimakum;
+    dynamic doodler;
+    dynamic emulsin;
+    dynamic fin;
+    dynamic flourishing;
+    dynamic flueless;
+    dynamic furtively;
+    dynamic gritter;
+    dynamic interwish;
+    dynamic monoxylic;
+    dynamic myristic;
+    dynamic nightwear;
+    dynamic peruser;
+    dynamic theoastrological;
+    dynamic thumby;
+    dynamic tingitid;
+    dynamic trailless;
+    dynamic unpocketed;
+
+    OccupationalistClass({
+        required this.beholdable,
+        required this.brotuliform,
+        required this.chimakum,
+        required this.doodler,
+        required this.emulsin,
+        required this.fin,
+        required this.flourishing,
+        required this.flueless,
+        required this.furtively,
+        required this.gritter,
+        required this.interwish,
+        required this.monoxylic,
+        required this.myristic,
+        required this.nightwear,
+        required this.peruser,
+        required this.theoastrological,
+        required this.thumby,
+        required this.tingitid,
+        required this.trailless,
+        required this.unpocketed,
+    });
+
+    factory OccupationalistClass.fromJson(Map<String, dynamic> json) => OccupationalistClass(
+        beholdable: json["beholdable"],
+        brotuliform: json["brotuliform"],
+        chimakum: json["Chimakum"],
+        doodler: json["doodler"],
+        emulsin: json["emulsin"],
+        fin: json["Fin"],
+        flourishing: json["flourishing"],
+        flueless: json["flueless"],
+        furtively: json["furtively"],
+        gritter: json["gritter"],
+        interwish: json["interwish"],
+        monoxylic: json["monoxylic"],
+        myristic: json["myristic"],
+        nightwear: json["nightwear"],
+        peruser: json["peruser"],
+        theoastrological: json["theoastrological"],
+        thumby: json["thumby"],
+        tingitid: json["tingitid"],
+        trailless: json["trailless"],
+        unpocketed: json["unpocketed"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "beholdable": beholdable,
+        "brotuliform": brotuliform,
+        "Chimakum": chimakum,
+        "doodler": doodler,
+        "emulsin": emulsin,
+        "Fin": fin,
+        "flourishing": flourishing,
+        "flueless": flueless,
+        "furtively": furtively,
+        "gritter": gritter,
+        "interwish": interwish,
+        "monoxylic": monoxylic,
+        "myristic": myristic,
+        "nightwear": nightwear,
+        "peruser": peruser,
+        "theoastrological": theoastrological,
+        "thumby": thumby,
+        "tingitid": tingitid,
+        "trailless": trailless,
+        "unpocketed": unpocketed,
+    };
+}
+
+class OutrivalClass {
+    dynamic adroitly;
+    dynamic bridehood;
+    dynamic castoroides;
+    dynamic czechoslovak;
+    dynamic diagenesis;
+    dynamic dihexahedron;
+    dynamic dopester;
+    dynamic eumerism;
+    dynamic flyness;
+    dynamic fouler;
+    dynamic laudanosine;
+    dynamic lingulidae;
+    dynamic minutary;
+    dynamic mitra;
+    dynamic opisthorchiasis;
+    dynamic pensively;
+    dynamic pubigerous;
+    dynamic rebellious;
+    dynamic recodify;
+    dynamic unpaced;
+
+    OutrivalClass({
+        required this.adroitly,
+        required this.bridehood,
+        required this.castoroides,
+        required this.czechoslovak,
+        required this.diagenesis,
+        required this.dihexahedron,
+        required this.dopester,
+        required this.eumerism,
+        required this.flyness,
+        required this.fouler,
+        required this.laudanosine,
+        required this.lingulidae,
+        required this.minutary,
+        required this.mitra,
+        required this.opisthorchiasis,
+        required this.pensively,
+        required this.pubigerous,
+        required this.rebellious,
+        required this.recodify,
+        required this.unpaced,
+    });
+
+    factory OutrivalClass.fromJson(Map<String, dynamic> json) => OutrivalClass(
+        adroitly: json["adroitly"],
+        bridehood: json["bridehood"],
+        castoroides: json["Castoroides"],
+        czechoslovak: json["Czechoslovak"],
+        diagenesis: json["diagenesis"],
+        dihexahedron: json["dihexahedron"],
+        dopester: json["dopester"],
+        eumerism: json["eumerism"],
+        flyness: json["flyness"],
+        fouler: json["fouler"],
+        laudanosine: json["laudanosine"],
+        lingulidae: json["Lingulidae"],
+        minutary: json["minutary"],
+        mitra: json["mitra"],
+        opisthorchiasis: json["opisthorchiasis"],
+        pensively: json["pensively"],
+        pubigerous: json["pubigerous"],
+        rebellious: json["rebellious"],
+        recodify: json["recodify"],
+        unpaced: json["unpaced"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "adroitly": adroitly,
+        "bridehood": bridehood,
+        "Castoroides": castoroides,
+        "Czechoslovak": czechoslovak,
+        "diagenesis": diagenesis,
+        "dihexahedron": dihexahedron,
+        "dopester": dopester,
+        "eumerism": eumerism,
+        "flyness": flyness,
+        "fouler": fouler,
+        "laudanosine": laudanosine,
+        "Lingulidae": lingulidae,
+        "minutary": minutary,
+        "mitra": mitra,
+        "opisthorchiasis": opisthorchiasis,
+        "pensively": pensively,
+        "pubigerous": pubigerous,
+        "rebellious": rebellious,
+        "recodify": recodify,
+        "unpaced": unpaced,
+    };
+}
+
+class PiaculumClass {
+    int? alada;
+    int? amphistomous;
+    int? boysenberry;
+    double? catharticalness;
+    int? chirotherium;
+    int? decardinalize;
+    int? discouragement;
+    String? disdiapason;
+    int? doitrified;
+    int? hexaspermous;
+    bool? homocerc;
+    int? insinking;
+    int? loathfulness;
+    int? miasmatical;
+    int? neurofibril;
+    dynamic nonbookish;
+    int? phonendoscope;
+    int? pilferment;
+    int? predismissory;
+    int? preinscription;
+    int? quotative;
+    int? sienna;
+    int? thorax;
+    int? yachting;
+    int? zipper;
+
+    PiaculumClass({
+        this.alada,
+        this.amphistomous,
+        this.boysenberry,
+        this.catharticalness,
+        this.chirotherium,
+        this.decardinalize,
+        this.discouragement,
+        this.disdiapason,
+        this.doitrified,
+        this.hexaspermous,
+        this.homocerc,
+        this.insinking,
+        this.loathfulness,
+        this.miasmatical,
+        this.neurofibril,
+        this.nonbookish,
+        this.phonendoscope,
+        this.pilferment,
+        this.predismissory,
+        this.preinscription,
+        this.quotative,
+        this.sienna,
+        this.thorax,
+        this.yachting,
+        this.zipper,
+    });
+
+    factory PiaculumClass.fromJson(Map<String, dynamic> json) => PiaculumClass(
+        alada: json["alada"],
+        amphistomous: json["amphistomous"],
+        boysenberry: json["boysenberry"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        decardinalize: json["decardinalize"],
+        discouragement: json["discouragement"],
+        disdiapason: json["disdiapason"],
+        doitrified: json["doitrified"],
+        hexaspermous: json["hexaspermous"],
+        homocerc: json["homocerc"],
+        insinking: json["insinking"],
+        loathfulness: json["loathfulness"],
+        miasmatical: json["miasmatical"],
+        neurofibril: json["neurofibril"],
+        nonbookish: json["nonbookish"],
+        phonendoscope: json["phonendoscope"],
+        pilferment: json["pilferment"],
+        predismissory: json["predismissory"],
+        preinscription: json["preinscription"],
+        quotative: json["quotative"],
+        sienna: json["sienna"],
+        thorax: json["thorax"],
+        yachting: json["yachting"],
+        zipper: json["Zipper"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "alada": alada,
+        "amphistomous": amphistomous,
+        "boysenberry": boysenberry,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "decardinalize": decardinalize,
+        "discouragement": discouragement,
+        "disdiapason": disdiapason,
+        "doitrified": doitrified,
+        "hexaspermous": hexaspermous,
+        "homocerc": homocerc,
+        "insinking": insinking,
+        "loathfulness": loathfulness,
+        "miasmatical": miasmatical,
+        "neurofibril": neurofibril,
+        "nonbookish": nonbookish,
+        "phonendoscope": phonendoscope,
+        "pilferment": pilferment,
+        "predismissory": predismissory,
+        "preinscription": preinscription,
+        "quotative": quotative,
+        "sienna": sienna,
+        "thorax": thorax,
+        "yachting": yachting,
+        "Zipper": zipper,
+    };
+}
+
+class Pneumocele {
+    dynamic carbonarism;
+    double? catharticalness;
+    int? chirotherium;
+    dynamic cineolic;
+    dynamic cobbly;
+    dynamic conchyliferous;
+    dynamic congregation;
+    String? disdiapason;
+    dynamic enterotomy;
+    dynamic entophytal;
+    dynamic fewtrils;
+    dynamic herem;
+    bool? homocerc;
+    dynamic koniga;
+    dynamic meticulosity;
+    dynamic micky;
+    dynamic mismarriage;
+    dynamic neurotrophic;
+    dynamic nonbookish;
+    dynamic persuasively;
+    dynamic replaceable;
+    dynamic silex;
+    dynamic taillight;
+    dynamic unjealous;
+    dynamic visitorial;
+
+    Pneumocele({
+        this.carbonarism,
+        this.catharticalness,
+        this.chirotherium,
+        this.cineolic,
+        this.cobbly,
+        this.conchyliferous,
+        this.congregation,
+        this.disdiapason,
+        this.enterotomy,
+        this.entophytal,
+        this.fewtrils,
+        this.herem,
+        this.homocerc,
+        this.koniga,
+        this.meticulosity,
+        this.micky,
+        this.mismarriage,
+        this.neurotrophic,
+        this.nonbookish,
+        this.persuasively,
+        this.replaceable,
+        this.silex,
+        this.taillight,
+        this.unjealous,
+        this.visitorial,
+    });
+
+    factory Pneumocele.fromJson(Map<String, dynamic> json) => Pneumocele(
+        carbonarism: json["Carbonarism"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        cineolic: json["cineolic"],
+        cobbly: json["cobbly"],
+        conchyliferous: json["conchyliferous"],
+        congregation: json["congregation"],
+        disdiapason: json["disdiapason"],
+        enterotomy: json["enterotomy"],
+        entophytal: json["entophytal"],
+        fewtrils: json["fewtrils"],
+        herem: json["herem"],
+        homocerc: json["homocerc"],
+        koniga: json["Koniga"],
+        meticulosity: json["meticulosity"],
+        micky: json["Micky"],
+        mismarriage: json["mismarriage"],
+        neurotrophic: json["neurotrophic"],
+        nonbookish: json["nonbookish"],
+        persuasively: json["persuasively"],
+        replaceable: json["replaceable"],
+        silex: json["silex"],
+        taillight: json["taillight"],
+        unjealous: json["unjealous"],
+        visitorial: json["visitorial"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Carbonarism": carbonarism,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "cineolic": cineolic,
+        "cobbly": cobbly,
+        "conchyliferous": conchyliferous,
+        "congregation": congregation,
+        "disdiapason": disdiapason,
+        "enterotomy": enterotomy,
+        "entophytal": entophytal,
+        "fewtrils": fewtrils,
+        "herem": herem,
+        "homocerc": homocerc,
+        "Koniga": koniga,
+        "meticulosity": meticulosity,
+        "Micky": micky,
+        "mismarriage": mismarriage,
+        "neurotrophic": neurotrophic,
+        "nonbookish": nonbookish,
+        "persuasively": persuasively,
+        "replaceable": replaceable,
+        "silex": silex,
+        "taillight": taillight,
+        "unjealous": unjealous,
+        "visitorial": visitorial,
+    };
+}
+
+class PotwhiskyClass {
+    dynamic arciform;
+    dynamic cresolin;
+    dynamic disheartener;
+    dynamic disproportionable;
+    dynamic euchorda;
+    dynamic ferryway;
+    dynamic filamentiferous;
+    dynamic flemish;
+    dynamic forgainst;
+    dynamic grainering;
+    dynamic irrevoluble;
+    dynamic kindredship;
+    dynamic pinguitudinous;
+    dynamic simpletonic;
+    dynamic singsong;
+    dynamic submergement;
+    dynamic supraoesophagal;
+    dynamic thrashel;
+    dynamic tyremesis;
+    dynamic yoruba;
+
+    PotwhiskyClass({
+        required this.arciform,
+        required this.cresolin,
+        required this.disheartener,
+        required this.disproportionable,
+        required this.euchorda,
+        required this.ferryway,
+        required this.filamentiferous,
+        required this.flemish,
+        required this.forgainst,
+        required this.grainering,
+        required this.irrevoluble,
+        required this.kindredship,
+        required this.pinguitudinous,
+        required this.simpletonic,
+        required this.singsong,
+        required this.submergement,
+        required this.supraoesophagal,
+        required this.thrashel,
+        required this.tyremesis,
+        required this.yoruba,
+    });
+
+    factory PotwhiskyClass.fromJson(Map<String, dynamic> json) => PotwhiskyClass(
+        arciform: json["arciform"],
+        cresolin: json["cresolin"],
+        disheartener: json["disheartener"],
+        disproportionable: json["disproportionable"],
+        euchorda: json["Euchorda"],
+        ferryway: json["ferryway"],
+        filamentiferous: json["filamentiferous"],
+        flemish: json["flemish"],
+        forgainst: json["forgainst"],
+        grainering: json["grainering"],
+        irrevoluble: json["irrevoluble"],
+        kindredship: json["kindredship"],
+        pinguitudinous: json["pinguitudinous"],
+        simpletonic: json["simpletonic"],
+        singsong: json["singsong"],
+        submergement: json["submergement"],
+        supraoesophagal: json["supraoesophagal"],
+        thrashel: json["thrashel"],
+        tyremesis: json["tyremesis"],
+        yoruba: json["Yoruba"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "arciform": arciform,
+        "cresolin": cresolin,
+        "disheartener": disheartener,
+        "disproportionable": disproportionable,
+        "Euchorda": euchorda,
+        "ferryway": ferryway,
+        "filamentiferous": filamentiferous,
+        "flemish": flemish,
+        "forgainst": forgainst,
+        "grainering": grainering,
+        "irrevoluble": irrevoluble,
+        "kindredship": kindredship,
+        "pinguitudinous": pinguitudinous,
+        "simpletonic": simpletonic,
+        "singsong": singsong,
+        "submergement": submergement,
+        "supraoesophagal": supraoesophagal,
+        "thrashel": thrashel,
+        "tyremesis": tyremesis,
+        "Yoruba": yoruba,
+    };
+}
+
+class PrefreshmanClass {
+    dynamic azorubine;
+    dynamic choroiditis;
+    dynamic coagulatory;
+    dynamic cyclorama;
+    dynamic dolphus;
+    dynamic duckhearted;
+    dynamic ficus;
+    dynamic gemaric;
+    dynamic jugation;
+    dynamic myoliposis;
+    dynamic nonnomination;
+    dynamic palay;
+    dynamic pentactinal;
+    dynamic phaet;
+    dynamic piquant;
+    dynamic registration;
+    dynamic remancipation;
+    dynamic scutatiform;
+    dynamic theodolite;
+    dynamic underward;
+
+    PrefreshmanClass({
+        required this.azorubine,
+        required this.choroiditis,
+        required this.coagulatory,
+        required this.cyclorama,
+        required this.dolphus,
+        required this.duckhearted,
+        required this.ficus,
+        required this.gemaric,
+        required this.jugation,
+        required this.myoliposis,
+        required this.nonnomination,
+        required this.palay,
+        required this.pentactinal,
+        required this.phaet,
+        required this.piquant,
+        required this.registration,
+        required this.remancipation,
+        required this.scutatiform,
+        required this.theodolite,
+        required this.underward,
+    });
+
+    factory PrefreshmanClass.fromJson(Map<String, dynamic> json) => PrefreshmanClass(
+        azorubine: json["azorubine"],
+        choroiditis: json["choroiditis"],
+        coagulatory: json["coagulatory"],
+        cyclorama: json["cyclorama"],
+        dolphus: json["Dolphus"],
+        duckhearted: json["duckhearted"],
+        ficus: json["Ficus"],
+        gemaric: json["Gemaric"],
+        jugation: json["jugation"],
+        myoliposis: json["myoliposis"],
+        nonnomination: json["nonnomination"],
+        palay: json["palay"],
+        pentactinal: json["pentactinal"],
+        phaet: json["Phaet"],
+        piquant: json["piquant"],
+        registration: json["registration"],
+        remancipation: json["remancipation"],
+        scutatiform: json["scutatiform"],
+        theodolite: json["theodolite"],
+        underward: json["underward"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "azorubine": azorubine,
+        "choroiditis": choroiditis,
+        "coagulatory": coagulatory,
+        "cyclorama": cyclorama,
+        "Dolphus": dolphus,
+        "duckhearted": duckhearted,
+        "Ficus": ficus,
+        "Gemaric": gemaric,
+        "jugation": jugation,
+        "myoliposis": myoliposis,
+        "nonnomination": nonnomination,
+        "palay": palay,
+        "pentactinal": pentactinal,
+        "Phaet": phaet,
+        "piquant": piquant,
+        "registration": registration,
+        "remancipation": remancipation,
+        "scutatiform": scutatiform,
+        "theodolite": theodolite,
+        "underward": underward,
+    };
+}
diff --git a/head/dart/test/inputs/json/priority/combinations4.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations4.json/default/TopLevel.dart
new file mode 100644
index 0000000..d2580eb
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/combinations4.json/default/TopLevel.dart
@@ -0,0 +1,1761 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<dynamic> protrusive;
+    final List<dynamic> pulpitism;
+    final List<dynamic> pyodermia;
+    final List<dynamic> quebrachine;
+    final List<dynamic> querier;
+    final List<dynamic> rebarbative;
+    final List<Reimagine> reimagine;
+    final Ressaut ressaut;
+    final List<dynamic> retrocervical;
+    final List<dynamic> revert;
+    final List<dynamic> rewrite;
+    final List<dynamic> saccoderm;
+    final List<dynamic> santir;
+    final List<dynamic> saprophilous;
+    final List<dynamic> saxten;
+    final List<Scatty?> scatty;
+    final List<dynamic> scoffer;
+    final List<dynamic> scrampum;
+    final double semantic;
+    final List<dynamic> serpentinic;
+    final List<dynamic> shadowable;
+    final List<dynamic> sistering;
+    final List<Staghunting> staghunting;
+    final List<dynamic> stagmometer;
+    final List<dynamic> stimulability;
+    final List<dynamic> strangleable;
+    final List<dynamic> strenuosity;
+    final List<dynamic> tabaxir;
+    final List<dynamic> talpiform;
+    final List<dynamic> thwack;
+    final List<double?> to;
+    final List<dynamic> tortricine;
+    final List<dynamic> truantcy;
+    final List<String> turgesce;
+    final List<dynamic> unbeginning;
+    final List<double> underdunged;
+    final List<dynamic> undesirability;
+    final List<dynamic> unerasing;
+    final List<dynamic> unguentarium;
+    final List<dynamic> unimpeachably;
+    final List<dynamic> unmortgaged;
+    final List<dynamic> unobstructed;
+    final List<dynamic> unreceptivity;
+    final List<dynamic> unsatisfactoriness;
+    final List<int> unsecurity;
+    final List<dynamic> unstressed;
+    final List<dynamic> untasked;
+    final List<dynamic> unvarying;
+    final List<dynamic> vehemently;
+    final Map<String, bool> warriorship;
+    final List<dynamic> whitepot;
+    final List<dynamic> wrothy;
+
+    TopLevel({
+        required this.protrusive,
+        required this.pulpitism,
+        required this.pyodermia,
+        required this.quebrachine,
+        required this.querier,
+        required this.rebarbative,
+        required this.reimagine,
+        required this.ressaut,
+        required this.retrocervical,
+        required this.revert,
+        required this.rewrite,
+        required this.saccoderm,
+        required this.santir,
+        required this.saprophilous,
+        required this.saxten,
+        required this.scatty,
+        required this.scoffer,
+        required this.scrampum,
+        required this.semantic,
+        required this.serpentinic,
+        required this.shadowable,
+        required this.sistering,
+        required this.staghunting,
+        required this.stagmometer,
+        required this.stimulability,
+        required this.strangleable,
+        required this.strenuosity,
+        required this.tabaxir,
+        required this.talpiform,
+        required this.thwack,
+        required this.to,
+        required this.tortricine,
+        required this.truantcy,
+        required this.turgesce,
+        required this.unbeginning,
+        required this.underdunged,
+        required this.undesirability,
+        required this.unerasing,
+        required this.unguentarium,
+        required this.unimpeachably,
+        required this.unmortgaged,
+        required this.unobstructed,
+        required this.unreceptivity,
+        required this.unsatisfactoriness,
+        required this.unsecurity,
+        required this.unstressed,
+        required this.untasked,
+        required this.unvarying,
+        required this.vehemently,
+        required this.warriorship,
+        required this.whitepot,
+        required this.wrothy,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        protrusive: List<dynamic>.from(json["protrusive"].map((x) => x)),
+        pulpitism: List<dynamic>.from(json["pulpitism"].map((x) => x)),
+        pyodermia: List<dynamic>.from(json["pyodermia"].map((x) => x)),
+        quebrachine: List<dynamic>.from(json["quebrachine"].map((x) => x)),
+        querier: List<dynamic>.from(json["querier"].map((x) => x)),
+        rebarbative: List<dynamic>.from(json["rebarbative"].map((x) => x)),
+        reimagine: List<Reimagine>.from(json["reimagine"].map((x) => Reimagine.fromJson(x))),
+        ressaut: Ressaut.fromJson(json["ressaut"]),
+        retrocervical: List<dynamic>.from(json["retrocervical"].map((x) => x)),
+        revert: List<dynamic>.from(json["revert"].map((x) => x)),
+        rewrite: List<dynamic>.from(json["rewrite"].map((x) => x)),
+        saccoderm: List<dynamic>.from(json["saccoderm"].map((x) => x)),
+        santir: List<dynamic>.from(json["santir"].map((x) => x)),
+        saprophilous: List<dynamic>.from(json["saprophilous"].map((x) => x)),
+        saxten: List<dynamic>.from(json["saxten"].map((x) => x)),
+        scatty: List<Scatty?>.from(json["scatty"].map((x) => x == null ? null : Scatty.fromJson(x))),
+        scoffer: List<dynamic>.from(json["scoffer"].map((x) => x)),
+        scrampum: List<dynamic>.from(json["scrampum"].map((x) => x)),
+        semantic: json["semantic"]?.toDouble(),
+        serpentinic: List<dynamic>.from(json["serpentinic"].map((x) => x)),
+        shadowable: List<dynamic>.from(json["shadowable"].map((x) => x)),
+        sistering: List<dynamic>.from(json["sistering"].map((x) => x)),
+        staghunting: List<Staghunting>.from(json["staghunting"].map((x) => Staghunting.fromJson(x))),
+        stagmometer: List<dynamic>.from(json["stagmometer"].map((x) => x)),
+        stimulability: List<dynamic>.from(json["stimulability"].map((x) => x)),
+        strangleable: List<dynamic>.from(json["strangleable"].map((x) => x)),
+        strenuosity: List<dynamic>.from(json["strenuosity"].map((x) => x)),
+        tabaxir: List<dynamic>.from(json["tabaxir"].map((x) => x)),
+        talpiform: List<dynamic>.from(json["talpiform"].map((x) => x)),
+        thwack: List<dynamic>.from(json["thwack"].map((x) => x)),
+        to: List<double?>.from(json["to"].map((x) => x?.toDouble())),
+        tortricine: List<dynamic>.from(json["tortricine"].map((x) => x)),
+        truantcy: List<dynamic>.from(json["truantcy"].map((x) => x)),
+        turgesce: List<String>.from(json["turgesce"].map((x) => x)),
+        unbeginning: List<dynamic>.from(json["unbeginning"].map((x) => x)),
+        underdunged: List<double>.from(json["underdunged"].map((x) => x?.toDouble())),
+        undesirability: List<dynamic>.from(json["undesirability"].map((x) => x)),
+        unerasing: List<dynamic>.from(json["unerasing"].map((x) => x)),
+        unguentarium: List<dynamic>.from(json["unguentarium"].map((x) => x)),
+        unimpeachably: List<dynamic>.from(json["unimpeachably"].map((x) => x)),
+        unmortgaged: List<dynamic>.from(json["unmortgaged"].map((x) => x)),
+        unobstructed: List<dynamic>.from(json["unobstructed"].map((x) => x)),
+        unreceptivity: List<dynamic>.from(json["unreceptivity"].map((x) => x)),
+        unsatisfactoriness: List<dynamic>.from(json["unsatisfactoriness"].map((x) => x)),
+        unsecurity: List<int>.from(json["unsecurity"].map((x) => x)),
+        unstressed: List<dynamic>.from(json["unstressed"].map((x) => x)),
+        untasked: List<dynamic>.from(json["untasked"].map((x) => x)),
+        unvarying: List<dynamic>.from(json["unvarying"].map((x) => x)),
+        vehemently: List<dynamic>.from(json["vehemently"].map((x) => x)),
+        warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry<String, bool>(k, v)),
+        whitepot: List<dynamic>.from(json["whitepot"].map((x) => x)),
+        wrothy: List<dynamic>.from(json["wrothy"].map((x) => x)),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "protrusive": List<dynamic>.from(protrusive.map((x) => x)),
+        "pulpitism": List<dynamic>.from(pulpitism.map((x) => x)),
+        "pyodermia": List<dynamic>.from(pyodermia.map((x) => x)),
+        "quebrachine": List<dynamic>.from(quebrachine.map((x) => x)),
+        "querier": List<dynamic>.from(querier.map((x) => x)),
+        "rebarbative": List<dynamic>.from(rebarbative.map((x) => x)),
+        "reimagine": List<dynamic>.from(reimagine.map((x) => x.toJson())),
+        "ressaut": ressaut.toJson(),
+        "retrocervical": List<dynamic>.from(retrocervical.map((x) => x)),
+        "revert": List<dynamic>.from(revert.map((x) => x)),
+        "rewrite": List<dynamic>.from(rewrite.map((x) => x)),
+        "saccoderm": List<dynamic>.from(saccoderm.map((x) => x)),
+        "santir": List<dynamic>.from(santir.map((x) => x)),
+        "saprophilous": List<dynamic>.from(saprophilous.map((x) => x)),
+        "saxten": List<dynamic>.from(saxten.map((x) => x)),
+        "scatty": List<dynamic>.from(scatty.map((x) => x?.toJson())),
+        "scoffer": List<dynamic>.from(scoffer.map((x) => x)),
+        "scrampum": List<dynamic>.from(scrampum.map((x) => x)),
+        "semantic": semantic,
+        "serpentinic": List<dynamic>.from(serpentinic.map((x) => x)),
+        "shadowable": List<dynamic>.from(shadowable.map((x) => x)),
+        "sistering": List<dynamic>.from(sistering.map((x) => x)),
+        "staghunting": List<dynamic>.from(staghunting.map((x) => x.toJson())),
+        "stagmometer": List<dynamic>.from(stagmometer.map((x) => x)),
+        "stimulability": List<dynamic>.from(stimulability.map((x) => x)),
+        "strangleable": List<dynamic>.from(strangleable.map((x) => x)),
+        "strenuosity": List<dynamic>.from(strenuosity.map((x) => x)),
+        "tabaxir": List<dynamic>.from(tabaxir.map((x) => x)),
+        "talpiform": List<dynamic>.from(talpiform.map((x) => x)),
+        "thwack": List<dynamic>.from(thwack.map((x) => x)),
+        "to": List<dynamic>.from(to.map((x) => x)),
+        "tortricine": List<dynamic>.from(tortricine.map((x) => x)),
+        "truantcy": List<dynamic>.from(truantcy.map((x) => x)),
+        "turgesce": List<dynamic>.from(turgesce.map((x) => x)),
+        "unbeginning": List<dynamic>.from(unbeginning.map((x) => x)),
+        "underdunged": List<dynamic>.from(underdunged.map((x) => x)),
+        "undesirability": List<dynamic>.from(undesirability.map((x) => x)),
+        "unerasing": List<dynamic>.from(unerasing.map((x) => x)),
+        "unguentarium": List<dynamic>.from(unguentarium.map((x) => x)),
+        "unimpeachably": List<dynamic>.from(unimpeachably.map((x) => x)),
+        "unmortgaged": List<dynamic>.from(unmortgaged.map((x) => x)),
+        "unobstructed": List<dynamic>.from(unobstructed.map((x) => x)),
+        "unreceptivity": List<dynamic>.from(unreceptivity.map((x) => x)),
+        "unsatisfactoriness": List<dynamic>.from(unsatisfactoriness.map((x) => x)),
+        "unsecurity": List<dynamic>.from(unsecurity.map((x) => x)),
+        "unstressed": List<dynamic>.from(unstressed.map((x) => x)),
+        "untasked": List<dynamic>.from(untasked.map((x) => x)),
+        "unvarying": List<dynamic>.from(unvarying.map((x) => x)),
+        "vehemently": List<dynamic>.from(vehemently.map((x) => x)),
+        "warriorship": Map.from(warriorship).map((k, v) => MapEntry<String, dynamic>(k, v)),
+        "whitepot": List<dynamic>.from(whitepot.map((x) => x)),
+        "wrothy": List<dynamic>.from(wrothy.map((x) => x)),
+    };
+}
+
+class PulpitismClass {
+    final dynamic abnet;
+    final dynamic buckhorn;
+    final dynamic calciform;
+    final dynamic chelophore;
+    final dynamic cogitation;
+    final dynamic decreeable;
+    final dynamic despicable;
+    final dynamic isodiazo;
+    final dynamic jadedly;
+    final dynamic leptochlorite;
+    final dynamic nursling;
+    final dynamic palamedean;
+    final dynamic photoheliograph;
+    final dynamic pipewood;
+    final dynamic roberd;
+    final dynamic statable;
+    final dynamic superassume;
+    final dynamic syllabe;
+    final dynamic toughhead;
+    final dynamic underburn;
+
+    PulpitismClass({
+        required this.abnet,
+        required this.buckhorn,
+        required this.calciform,
+        required this.chelophore,
+        required this.cogitation,
+        required this.decreeable,
+        required this.despicable,
+        required this.isodiazo,
+        required this.jadedly,
+        required this.leptochlorite,
+        required this.nursling,
+        required this.palamedean,
+        required this.photoheliograph,
+        required this.pipewood,
+        required this.roberd,
+        required this.statable,
+        required this.superassume,
+        required this.syllabe,
+        required this.toughhead,
+        required this.underburn,
+    });
+
+    factory PulpitismClass.fromJson(Map<String, dynamic> json) => PulpitismClass(
+        abnet: json["abnet"],
+        buckhorn: json["buckhorn"],
+        calciform: json["calciform"],
+        chelophore: json["chelophore"],
+        cogitation: json["cogitation"],
+        decreeable: json["decreeable"],
+        despicable: json["despicable"],
+        isodiazo: json["isodiazo"],
+        jadedly: json["jadedly"],
+        leptochlorite: json["leptochlorite"],
+        nursling: json["nursling"],
+        palamedean: json["palamedean"],
+        photoheliograph: json["photoheliograph"],
+        pipewood: json["pipewood"],
+        roberd: json["roberd"],
+        statable: json["statable"],
+        superassume: json["superassume"],
+        syllabe: json["syllabe"],
+        toughhead: json["toughhead"],
+        underburn: json["underburn"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "abnet": abnet,
+        "buckhorn": buckhorn,
+        "calciform": calciform,
+        "chelophore": chelophore,
+        "cogitation": cogitation,
+        "decreeable": decreeable,
+        "despicable": despicable,
+        "isodiazo": isodiazo,
+        "jadedly": jadedly,
+        "leptochlorite": leptochlorite,
+        "nursling": nursling,
+        "palamedean": palamedean,
+        "photoheliograph": photoheliograph,
+        "pipewood": pipewood,
+        "roberd": roberd,
+        "statable": statable,
+        "superassume": superassume,
+        "syllabe": syllabe,
+        "toughhead": toughhead,
+        "underburn": underburn,
+    };
+}
+
+class PyodermiaClass {
+    final dynamic aphoristically;
+    final dynamic apophyllous;
+    final dynamic cognize;
+    final dynamic dermonosology;
+    final dynamic gyppo;
+    final dynamic ither;
+    final dynamic juglandaceous;
+    final dynamic litho;
+    final dynamic macropterous;
+    final dynamic photographer;
+    final dynamic romancing;
+    final dynamic rumness;
+    final dynamic somniloquist;
+    final dynamic stressfully;
+    final dynamic tactically;
+    final dynamic tracheophony;
+    final dynamic unappositely;
+    final dynamic unclothedly;
+    final dynamic unimplied;
+    final dynamic unsyncopated;
+
+    PyodermiaClass({
+        required this.aphoristically,
+        required this.apophyllous,
+        required this.cognize,
+        required this.dermonosology,
+        required this.gyppo,
+        required this.ither,
+        required this.juglandaceous,
+        required this.litho,
+        required this.macropterous,
+        required this.photographer,
+        required this.romancing,
+        required this.rumness,
+        required this.somniloquist,
+        required this.stressfully,
+        required this.tactically,
+        required this.tracheophony,
+        required this.unappositely,
+        required this.unclothedly,
+        required this.unimplied,
+        required this.unsyncopated,
+    });
+
+    factory PyodermiaClass.fromJson(Map<String, dynamic> json) => PyodermiaClass(
+        aphoristically: json["aphoristically"],
+        apophyllous: json["apophyllous"],
+        cognize: json["cognize"],
+        dermonosology: json["dermonosology"],
+        gyppo: json["Gyppo"],
+        ither: json["ither"],
+        juglandaceous: json["juglandaceous"],
+        litho: json["litho"],
+        macropterous: json["macropterous"],
+        photographer: json["photographer"],
+        romancing: json["romancing"],
+        rumness: json["rumness"],
+        somniloquist: json["somniloquist"],
+        stressfully: json["stressfully"],
+        tactically: json["tactically"],
+        tracheophony: json["tracheophony"],
+        unappositely: json["unappositely"],
+        unclothedly: json["unclothedly"],
+        unimplied: json["unimplied"],
+        unsyncopated: json["unsyncopated"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "aphoristically": aphoristically,
+        "apophyllous": apophyllous,
+        "cognize": cognize,
+        "dermonosology": dermonosology,
+        "Gyppo": gyppo,
+        "ither": ither,
+        "juglandaceous": juglandaceous,
+        "litho": litho,
+        "macropterous": macropterous,
+        "photographer": photographer,
+        "romancing": romancing,
+        "rumness": rumness,
+        "somniloquist": somniloquist,
+        "stressfully": stressfully,
+        "tactically": tactically,
+        "tracheophony": tracheophony,
+        "unappositely": unappositely,
+        "unclothedly": unclothedly,
+        "unimplied": unimplied,
+        "unsyncopated": unsyncopated,
+    };
+}
+
+class QuebrachineClass {
+    final double catharticalness;
+    final int chirotherium;
+    final String disdiapason;
+    final bool homocerc;
+    final dynamic nonbookish;
+
+    QuebrachineClass({
+        required this.catharticalness,
+        required this.chirotherium,
+        required this.disdiapason,
+        required this.homocerc,
+        required this.nonbookish,
+    });
+
+    factory QuebrachineClass.fromJson(Map<String, dynamic> json) => QuebrachineClass(
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        homocerc: json["homocerc"],
+        nonbookish: json["nonbookish"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "homocerc": homocerc,
+        "nonbookish": nonbookish,
+    };
+}
+
+class Reimagine {
+    final dynamic adducible;
+    final dynamic anabolin;
+    final dynamic brainy;
+    final double? catharticalness;
+    final int? chirotherium;
+    final dynamic chrysamine;
+    final String? disdiapason;
+    final dynamic fluxweed;
+    final dynamic glaucine;
+    final dynamic grobianism;
+    final dynamic hermo;
+    final dynamic hieroglyphist;
+    final bool? homocerc;
+    final dynamic icteroid;
+    final dynamic immortal;
+    final dynamic impetulant;
+    final dynamic irrigate;
+    final dynamic myxedema;
+    final dynamic nonbookish;
+    final dynamic onyx;
+    final dynamic repasser;
+    final dynamic septomarginal;
+    final dynamic subdie;
+    final dynamic tibiometatarsal;
+    final dynamic waltzlike;
+
+    Reimagine({
+        this.adducible,
+        this.anabolin,
+        this.brainy,
+        this.catharticalness,
+        this.chirotherium,
+        this.chrysamine,
+        this.disdiapason,
+        this.fluxweed,
+        this.glaucine,
+        this.grobianism,
+        this.hermo,
+        this.hieroglyphist,
+        this.homocerc,
+        this.icteroid,
+        this.immortal,
+        this.impetulant,
+        this.irrigate,
+        this.myxedema,
+        this.nonbookish,
+        this.onyx,
+        this.repasser,
+        this.septomarginal,
+        this.subdie,
+        this.tibiometatarsal,
+        this.waltzlike,
+    });
+
+    factory Reimagine.fromJson(Map<String, dynamic> json) => Reimagine(
+        adducible: json["adducible"],
+        anabolin: json["anabolin"],
+        brainy: json["brainy"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chrysamine: json["chrysamine"],
+        disdiapason: json["disdiapason"],
+        fluxweed: json["fluxweed"],
+        glaucine: json["glaucine"],
+        grobianism: json["grobianism"],
+        hermo: json["Hermo"],
+        hieroglyphist: json["hieroglyphist"],
+        homocerc: json["homocerc"],
+        icteroid: json["icteroid"],
+        immortal: json["immortal"],
+        impetulant: json["impetulant"],
+        irrigate: json["irrigate"],
+        myxedema: json["myxedema"],
+        nonbookish: json["nonbookish"],
+        onyx: json["onyx"],
+        repasser: json["repasser"],
+        septomarginal: json["septomarginal"],
+        subdie: json["subdie"],
+        tibiometatarsal: json["tibiometatarsal"],
+        waltzlike: json["waltzlike"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "adducible": adducible,
+        "anabolin": anabolin,
+        "brainy": brainy,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "chrysamine": chrysamine,
+        "disdiapason": disdiapason,
+        "fluxweed": fluxweed,
+        "glaucine": glaucine,
+        "grobianism": grobianism,
+        "Hermo": hermo,
+        "hieroglyphist": hieroglyphist,
+        "homocerc": homocerc,
+        "icteroid": icteroid,
+        "immortal": immortal,
+        "impetulant": impetulant,
+        "irrigate": irrigate,
+        "myxedema": myxedema,
+        "nonbookish": nonbookish,
+        "onyx": onyx,
+        "repasser": repasser,
+        "septomarginal": septomarginal,
+        "subdie": subdie,
+        "tibiometatarsal": tibiometatarsal,
+        "waltzlike": waltzlike,
+    };
+}
+
+class Ressaut {
+    final String apperceptive;
+    final String cuttoo;
+    final String douser;
+    final String drinkproof;
+    final String forementioned;
+    final String freesia;
+    final String genevieve;
+    final String hyperdiabolical;
+    final String hypocone;
+    final String irreverentially;
+    final String jumart;
+    final String mimosaceae;
+    final String mollicrush;
+    final String nedder;
+    final String retinasphalt;
+    final String sough;
+    final String steading;
+    final String theopaschitism;
+    final String undurableness;
+    final String unmingleable;
+
+    Ressaut({
+        required this.apperceptive,
+        required this.cuttoo,
+        required this.douser,
+        required this.drinkproof,
+        required this.forementioned,
+        required this.freesia,
+        required this.genevieve,
+        required this.hyperdiabolical,
+        required this.hypocone,
+        required this.irreverentially,
+        required this.jumart,
+        required this.mimosaceae,
+        required this.mollicrush,
+        required this.nedder,
+        required this.retinasphalt,
+        required this.sough,
+        required this.steading,
+        required this.theopaschitism,
+        required this.undurableness,
+        required this.unmingleable,
+    });
+
+    factory Ressaut.fromJson(Map<String, dynamic> json) => Ressaut(
+        apperceptive: json["apperceptive"],
+        cuttoo: json["cuttoo"],
+        douser: json["douser"],
+        drinkproof: json["drinkproof"],
+        forementioned: json["forementioned"],
+        freesia: json["Freesia"],
+        genevieve: json["Genevieve"],
+        hyperdiabolical: json["hyperdiabolical"],
+        hypocone: json["hypocone"],
+        irreverentially: json["irreverentially"],
+        jumart: json["jumart"],
+        mimosaceae: json["Mimosaceae"],
+        mollicrush: json["mollicrush"],
+        nedder: json["nedder"],
+        retinasphalt: json["retinasphalt"],
+        sough: json["sough"],
+        steading: json["steading"],
+        theopaschitism: json["Theopaschitism"],
+        undurableness: json["undurableness"],
+        unmingleable: json["unmingleable"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "apperceptive": apperceptive,
+        "cuttoo": cuttoo,
+        "douser": douser,
+        "drinkproof": drinkproof,
+        "forementioned": forementioned,
+        "Freesia": freesia,
+        "Genevieve": genevieve,
+        "hyperdiabolical": hyperdiabolical,
+        "hypocone": hypocone,
+        "irreverentially": irreverentially,
+        "jumart": jumart,
+        "Mimosaceae": mimosaceae,
+        "mollicrush": mollicrush,
+        "nedder": nedder,
+        "retinasphalt": retinasphalt,
+        "sough": sough,
+        "steading": steading,
+        "Theopaschitism": theopaschitism,
+        "undurableness": undurableness,
+        "unmingleable": unmingleable,
+    };
+}
+
+class RewriteClass {
+    final dynamic accountancy;
+    final dynamic cacotrophic;
+    final dynamic contest;
+    final dynamic couthily;
+    final dynamic falculate;
+    final dynamic foreseize;
+    final dynamic hyades;
+    final dynamic lemnad;
+    final dynamic monotheistically;
+    final dynamic nonflying;
+    final dynamic ptenoglossa;
+    final dynamic repatch;
+    final dynamic rodman;
+    final dynamic strung;
+    final dynamic titmal;
+    final dynamic twalpennyworth;
+    final dynamic unblamable;
+    final dynamic vertical;
+    final dynamic whiggification;
+    final dynamic yardman;
+
+    RewriteClass({
+        required this.accountancy,
+        required this.cacotrophic,
+        required this.contest,
+        required this.couthily,
+        required this.falculate,
+        required this.foreseize,
+        required this.hyades,
+        required this.lemnad,
+        required this.monotheistically,
+        required this.nonflying,
+        required this.ptenoglossa,
+        required this.repatch,
+        required this.rodman,
+        required this.strung,
+        required this.titmal,
+        required this.twalpennyworth,
+        required this.unblamable,
+        required this.vertical,
+        required this.whiggification,
+        required this.yardman,
+    });
+
+    factory RewriteClass.fromJson(Map<String, dynamic> json) => RewriteClass(
+        accountancy: json["accountancy"],
+        cacotrophic: json["cacotrophic"],
+        contest: json["contest"],
+        couthily: json["couthily"],
+        falculate: json["falculate"],
+        foreseize: json["foreseize"],
+        hyades: json["Hyades"],
+        lemnad: json["lemnad"],
+        monotheistically: json["monotheistically"],
+        nonflying: json["nonflying"],
+        ptenoglossa: json["Ptenoglossa"],
+        repatch: json["repatch"],
+        rodman: json["rodman"],
+        strung: json["strung"],
+        titmal: json["titmal"],
+        twalpennyworth: json["twalpennyworth"],
+        unblamable: json["unblamable"],
+        vertical: json["vertical"],
+        whiggification: json["Whiggification"],
+        yardman: json["yardman"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "accountancy": accountancy,
+        "cacotrophic": cacotrophic,
+        "contest": contest,
+        "couthily": couthily,
+        "falculate": falculate,
+        "foreseize": foreseize,
+        "Hyades": hyades,
+        "lemnad": lemnad,
+        "monotheistically": monotheistically,
+        "nonflying": nonflying,
+        "Ptenoglossa": ptenoglossa,
+        "repatch": repatch,
+        "rodman": rodman,
+        "strung": strung,
+        "titmal": titmal,
+        "twalpennyworth": twalpennyworth,
+        "unblamable": unblamable,
+        "vertical": vertical,
+        "Whiggification": whiggification,
+        "yardman": yardman,
+    };
+}
+
+class SantirClass {
+    final dynamic admiredly;
+    final dynamic demicaponier;
+    final dynamic epitympanic;
+    final dynamic investitor;
+    final dynamic lupiform;
+    final dynamic monoflagellate;
+    final dynamic paleoethnic;
+    final dynamic prediscountable;
+    final dynamic rhetoricals;
+    final dynamic roomth;
+    final dynamic saccharose;
+    final dynamic septonasal;
+    final dynamic serpenticide;
+    final dynamic setarious;
+    final dynamic spaework;
+    final dynamic stylite;
+    final dynamic suessiones;
+    final dynamic timelily;
+    final dynamic unprofaned;
+    final dynamic vorticular;
+
+    SantirClass({
+        required this.admiredly,
+        required this.demicaponier,
+        required this.epitympanic,
+        required this.investitor,
+        required this.lupiform,
+        required this.monoflagellate,
+        required this.paleoethnic,
+        required this.prediscountable,
+        required this.rhetoricals,
+        required this.roomth,
+        required this.saccharose,
+        required this.septonasal,
+        required this.serpenticide,
+        required this.setarious,
+        required this.spaework,
+        required this.stylite,
+        required this.suessiones,
+        required this.timelily,
+        required this.unprofaned,
+        required this.vorticular,
+    });
+
+    factory SantirClass.fromJson(Map<String, dynamic> json) => SantirClass(
+        admiredly: json["admiredly"],
+        demicaponier: json["demicaponier"],
+        epitympanic: json["epitympanic"],
+        investitor: json["investitor"],
+        lupiform: json["lupiform"],
+        monoflagellate: json["monoflagellate"],
+        paleoethnic: json["paleoethnic"],
+        prediscountable: json["prediscountable"],
+        rhetoricals: json["rhetoricals"],
+        roomth: json["roomth"],
+        saccharose: json["saccharose"],
+        septonasal: json["septonasal"],
+        serpenticide: json["serpenticide"],
+        setarious: json["setarious"],
+        spaework: json["spaework"],
+        stylite: json["stylite"],
+        suessiones: json["Suessiones"],
+        timelily: json["timelily"],
+        unprofaned: json["unprofaned"],
+        vorticular: json["vorticular"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "admiredly": admiredly,
+        "demicaponier": demicaponier,
+        "epitympanic": epitympanic,
+        "investitor": investitor,
+        "lupiform": lupiform,
+        "monoflagellate": monoflagellate,
+        "paleoethnic": paleoethnic,
+        "prediscountable": prediscountable,
+        "rhetoricals": rhetoricals,
+        "roomth": roomth,
+        "saccharose": saccharose,
+        "septonasal": septonasal,
+        "serpenticide": serpenticide,
+        "setarious": setarious,
+        "spaework": spaework,
+        "stylite": stylite,
+        "Suessiones": suessiones,
+        "timelily": timelily,
+        "unprofaned": unprofaned,
+        "vorticular": vorticular,
+    };
+}
+
+class SaxtenClass {
+    final dynamic algarrobilla;
+    final dynamic bowgrace;
+    final double? catharticalness;
+    final dynamic centaurid;
+    final int? chirotherium;
+    final String? disdiapason;
+    final dynamic flix;
+    final dynamic germanely;
+    final bool? homocerc;
+    final dynamic inhume;
+    final dynamic lepidote;
+    final dynamic megalochirous;
+    final dynamic ninepenny;
+    final dynamic nonbookish;
+    final dynamic nondeist;
+    final dynamic nymphaeaceous;
+    final dynamic parietofrontal;
+    final dynamic sancyite;
+    final dynamic subjectivist;
+    final dynamic tibiad;
+    final dynamic transonic;
+    final dynamic tripetalous;
+    final dynamic trunchman;
+    final dynamic urger;
+    final dynamic withdrawnness;
+
+    SaxtenClass({
+        this.algarrobilla,
+        this.bowgrace,
+        this.catharticalness,
+        this.centaurid,
+        this.chirotherium,
+        this.disdiapason,
+        this.flix,
+        this.germanely,
+        this.homocerc,
+        this.inhume,
+        this.lepidote,
+        this.megalochirous,
+        this.ninepenny,
+        this.nonbookish,
+        this.nondeist,
+        this.nymphaeaceous,
+        this.parietofrontal,
+        this.sancyite,
+        this.subjectivist,
+        this.tibiad,
+        this.transonic,
+        this.tripetalous,
+        this.trunchman,
+        this.urger,
+        this.withdrawnness,
+    });
+
+    factory SaxtenClass.fromJson(Map<String, dynamic> json) => SaxtenClass(
+        algarrobilla: json["algarrobilla"],
+        bowgrace: json["bowgrace"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        centaurid: json["Centaurid"],
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        flix: json["flix"],
+        germanely: json["germanely"],
+        homocerc: json["homocerc"],
+        inhume: json["inhume"],
+        lepidote: json["lepidote"],
+        megalochirous: json["megalochirous"],
+        ninepenny: json["ninepenny"],
+        nonbookish: json["nonbookish"],
+        nondeist: json["nondeist"],
+        nymphaeaceous: json["nymphaeaceous"],
+        parietofrontal: json["parietofrontal"],
+        sancyite: json["sancyite"],
+        subjectivist: json["subjectivist"],
+        tibiad: json["tibiad"],
+        transonic: json["transonic"],
+        tripetalous: json["tripetalous"],
+        trunchman: json["trunchman"],
+        urger: json["urger"],
+        withdrawnness: json["withdrawnness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "algarrobilla": algarrobilla,
+        "bowgrace": bowgrace,
+        "catharticalness": catharticalness,
+        "Centaurid": centaurid,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "flix": flix,
+        "germanely": germanely,
+        "homocerc": homocerc,
+        "inhume": inhume,
+        "lepidote": lepidote,
+        "megalochirous": megalochirous,
+        "ninepenny": ninepenny,
+        "nonbookish": nonbookish,
+        "nondeist": nondeist,
+        "nymphaeaceous": nymphaeaceous,
+        "parietofrontal": parietofrontal,
+        "sancyite": sancyite,
+        "subjectivist": subjectivist,
+        "tibiad": tibiad,
+        "transonic": transonic,
+        "tripetalous": tripetalous,
+        "trunchman": trunchman,
+        "urger": urger,
+        "withdrawnness": withdrawnness,
+    };
+}
+
+class Scatty {
+    final dynamic aeriferous;
+    final dynamic antical;
+    final dynamic antighostism;
+    final dynamic arcanum;
+    final dynamic autotrophy;
+    final dynamic baronial;
+    final dynamic caffeine;
+    final dynamic gorgoniacean;
+    final dynamic heroical;
+    final dynamic hydropical;
+    final dynamic mechanology;
+    final dynamic musicopoetic;
+    final dynamic officiality;
+    final dynamic oftentimes;
+    final dynamic ophthalmotonometer;
+    final dynamic reflectively;
+    final dynamic springer;
+    final dynamic tabasco;
+    final dynamic teleianthous;
+    final dynamic uncombated;
+
+    Scatty({
+        required this.aeriferous,
+        required this.antical,
+        required this.antighostism,
+        required this.arcanum,
+        required this.autotrophy,
+        required this.baronial,
+        required this.caffeine,
+        required this.gorgoniacean,
+        required this.heroical,
+        required this.hydropical,
+        required this.mechanology,
+        required this.musicopoetic,
+        required this.officiality,
+        required this.oftentimes,
+        required this.ophthalmotonometer,
+        required this.reflectively,
+        required this.springer,
+        required this.tabasco,
+        required this.teleianthous,
+        required this.uncombated,
+    });
+
+    factory Scatty.fromJson(Map<String, dynamic> json) => Scatty(
+        aeriferous: json["aeriferous"],
+        antical: json["antical"],
+        antighostism: json["antighostism"],
+        arcanum: json["arcanum"],
+        autotrophy: json["autotrophy"],
+        baronial: json["baronial"],
+        caffeine: json["caffeine"],
+        gorgoniacean: json["gorgoniacean"],
+        heroical: json["heroical"],
+        hydropical: json["hydropical"],
+        mechanology: json["mechanology"],
+        musicopoetic: json["musicopoetic"],
+        officiality: json["officiality"],
+        oftentimes: json["oftentimes"],
+        ophthalmotonometer: json["ophthalmotonometer"],
+        reflectively: json["reflectively"],
+        springer: json["springer"],
+        tabasco: json["Tabasco"],
+        teleianthous: json["teleianthous"],
+        uncombated: json["uncombated"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "aeriferous": aeriferous,
+        "antical": antical,
+        "antighostism": antighostism,
+        "arcanum": arcanum,
+        "autotrophy": autotrophy,
+        "baronial": baronial,
+        "caffeine": caffeine,
+        "gorgoniacean": gorgoniacean,
+        "heroical": heroical,
+        "hydropical": hydropical,
+        "mechanology": mechanology,
+        "musicopoetic": musicopoetic,
+        "officiality": officiality,
+        "oftentimes": oftentimes,
+        "ophthalmotonometer": ophthalmotonometer,
+        "reflectively": reflectively,
+        "springer": springer,
+        "Tabasco": tabasco,
+        "teleianthous": teleianthous,
+        "uncombated": uncombated,
+    };
+}
+
+class SisteringClass {
+    final dynamic amphicarpic;
+    final dynamic chianti;
+    final dynamic frigorific;
+    final dynamic haplomi;
+    final dynamic hyperkinesis;
+    final dynamic laudable;
+    final dynamic madwoman;
+    final dynamic maimedly;
+    final dynamic micropterygidae;
+    final dynamic microrhabdus;
+    final dynamic nondense;
+    final dynamic phlebemphraxis;
+    final dynamic redsear;
+    final dynamic schismatical;
+    final dynamic tartryl;
+    final dynamic unabhorred;
+    final dynamic undeliberateness;
+    final dynamic unmixable;
+    final dynamic untruckling;
+    final dynamic vineal;
+
+    SisteringClass({
+        required this.amphicarpic,
+        required this.chianti,
+        required this.frigorific,
+        required this.haplomi,
+        required this.hyperkinesis,
+        required this.laudable,
+        required this.madwoman,
+        required this.maimedly,
+        required this.micropterygidae,
+        required this.microrhabdus,
+        required this.nondense,
+        required this.phlebemphraxis,
+        required this.redsear,
+        required this.schismatical,
+        required this.tartryl,
+        required this.unabhorred,
+        required this.undeliberateness,
+        required this.unmixable,
+        required this.untruckling,
+        required this.vineal,
+    });
+
+    factory SisteringClass.fromJson(Map<String, dynamic> json) => SisteringClass(
+        amphicarpic: json["amphicarpic"],
+        chianti: json["Chianti"],
+        frigorific: json["frigorific"],
+        haplomi: json["Haplomi"],
+        hyperkinesis: json["hyperkinesis"],
+        laudable: json["laudable"],
+        madwoman: json["madwoman"],
+        maimedly: json["maimedly"],
+        micropterygidae: json["Micropterygidae"],
+        microrhabdus: json["microrhabdus"],
+        nondense: json["nondense"],
+        phlebemphraxis: json["phlebemphraxis"],
+        redsear: json["redsear"],
+        schismatical: json["schismatical"],
+        tartryl: json["tartryl"],
+        unabhorred: json["unabhorred"],
+        undeliberateness: json["undeliberateness"],
+        unmixable: json["unmixable"],
+        untruckling: json["untruckling"],
+        vineal: json["vineal"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "amphicarpic": amphicarpic,
+        "Chianti": chianti,
+        "frigorific": frigorific,
+        "Haplomi": haplomi,
+        "hyperkinesis": hyperkinesis,
+        "laudable": laudable,
+        "madwoman": madwoman,
+        "maimedly": maimedly,
+        "Micropterygidae": micropterygidae,
+        "microrhabdus": microrhabdus,
+        "nondense": nondense,
+        "phlebemphraxis": phlebemphraxis,
+        "redsear": redsear,
+        "schismatical": schismatical,
+        "tartryl": tartryl,
+        "unabhorred": unabhorred,
+        "undeliberateness": undeliberateness,
+        "unmixable": unmixable,
+        "untruckling": untruckling,
+        "vineal": vineal,
+    };
+}
+
+class Staghunting {
+    final int? calorimetric;
+    final int? canid;
+    final double? catharticalness;
+    final int? chirotherium;
+    final String? disdiapason;
+    final int? ditriglyphic;
+    final int? floriferousness;
+    final int? gamelike;
+    final int? grig;
+    final bool? homocerc;
+    final int? interloan;
+    final int? lithotomy;
+    final int? loric;
+    final int? membranocoriaceous;
+    final int? membranogenic;
+    final dynamic nonbookish;
+    final int? overtrump;
+    final int? scotino;
+    final int? seasonable;
+    final int? sephen;
+    final int? stigmarioid;
+    final int? tired;
+    final int? trifid;
+    final int? undefeatedly;
+    final int? ungirlish;
+
+    Staghunting({
+        this.calorimetric,
+        this.canid,
+        this.catharticalness,
+        this.chirotherium,
+        this.disdiapason,
+        this.ditriglyphic,
+        this.floriferousness,
+        this.gamelike,
+        this.grig,
+        this.homocerc,
+        this.interloan,
+        this.lithotomy,
+        this.loric,
+        this.membranocoriaceous,
+        this.membranogenic,
+        this.nonbookish,
+        this.overtrump,
+        this.scotino,
+        this.seasonable,
+        this.sephen,
+        this.stigmarioid,
+        this.tired,
+        this.trifid,
+        this.undefeatedly,
+        this.ungirlish,
+    });
+
+    factory Staghunting.fromJson(Map<String, dynamic> json) => Staghunting(
+        calorimetric: json["calorimetric"],
+        canid: json["canid"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        ditriglyphic: json["ditriglyphic"],
+        floriferousness: json["floriferousness"],
+        gamelike: json["gamelike"],
+        grig: json["grig"],
+        homocerc: json["homocerc"],
+        interloan: json["interloan"],
+        lithotomy: json["lithotomy"],
+        loric: json["loric"],
+        membranocoriaceous: json["membranocoriaceous"],
+        membranogenic: json["membranogenic"],
+        nonbookish: json["nonbookish"],
+        overtrump: json["overtrump"],
+        scotino: json["scotino"],
+        seasonable: json["seasonable"],
+        sephen: json["sephen"],
+        stigmarioid: json["stigmarioid"],
+        tired: json["tired"],
+        trifid: json["trifid"],
+        undefeatedly: json["undefeatedly"],
+        ungirlish: json["ungirlish"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "calorimetric": calorimetric,
+        "canid": canid,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "ditriglyphic": ditriglyphic,
+        "floriferousness": floriferousness,
+        "gamelike": gamelike,
+        "grig": grig,
+        "homocerc": homocerc,
+        "interloan": interloan,
+        "lithotomy": lithotomy,
+        "loric": loric,
+        "membranocoriaceous": membranocoriaceous,
+        "membranogenic": membranogenic,
+        "nonbookish": nonbookish,
+        "overtrump": overtrump,
+        "scotino": scotino,
+        "seasonable": seasonable,
+        "sephen": sephen,
+        "stigmarioid": stigmarioid,
+        "tired": tired,
+        "trifid": trifid,
+        "undefeatedly": undefeatedly,
+        "ungirlish": ungirlish,
+    };
+}
+
+class StrenuosityClass {
+    final int? bliss;
+    final int? buccate;
+    final int? bulletproof;
+    final double? catharticalness;
+    final int? chirotherium;
+    final int? crumblingness;
+    final String? disdiapason;
+    final int? engagedly;
+    final int? fightable;
+    final int? hoariness;
+    final bool? homocerc;
+    final int? hypopodium;
+    final int? luxurist;
+    final int? mechanician;
+    final dynamic nonbookish;
+    final int? onopordon;
+    final int? podgily;
+    final int? reformableness;
+    final int? scatterbrains;
+    final int? seminuria;
+    final int? sodomite;
+    final int? tramp;
+    final int? undueness;
+    final int? worthily;
+    final int? yankeeist;
+
+    StrenuosityClass({
+        this.bliss,
+        this.buccate,
+        this.bulletproof,
+        this.catharticalness,
+        this.chirotherium,
+        this.crumblingness,
+        this.disdiapason,
+        this.engagedly,
+        this.fightable,
+        this.hoariness,
+        this.homocerc,
+        this.hypopodium,
+        this.luxurist,
+        this.mechanician,
+        this.nonbookish,
+        this.onopordon,
+        this.podgily,
+        this.reformableness,
+        this.scatterbrains,
+        this.seminuria,
+        this.sodomite,
+        this.tramp,
+        this.undueness,
+        this.worthily,
+        this.yankeeist,
+    });
+
+    factory StrenuosityClass.fromJson(Map<String, dynamic> json) => StrenuosityClass(
+        bliss: json["bliss"],
+        buccate: json["buccate"],
+        bulletproof: json["bulletproof"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        crumblingness: json["crumblingness"],
+        disdiapason: json["disdiapason"],
+        engagedly: json["engagedly"],
+        fightable: json["fightable"],
+        hoariness: json["hoariness"],
+        homocerc: json["homocerc"],
+        hypopodium: json["hypopodium"],
+        luxurist: json["luxurist"],
+        mechanician: json["mechanician"],
+        nonbookish: json["nonbookish"],
+        onopordon: json["Onopordon"],
+        podgily: json["podgily"],
+        reformableness: json["reformableness"],
+        scatterbrains: json["scatterbrains"],
+        seminuria: json["seminuria"],
+        sodomite: json["Sodomite"],
+        tramp: json["tramp"],
+        undueness: json["undueness"],
+        worthily: json["worthily"],
+        yankeeist: json["Yankeeist"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "bliss": bliss,
+        "buccate": buccate,
+        "bulletproof": bulletproof,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "crumblingness": crumblingness,
+        "disdiapason": disdiapason,
+        "engagedly": engagedly,
+        "fightable": fightable,
+        "hoariness": hoariness,
+        "homocerc": homocerc,
+        "hypopodium": hypopodium,
+        "luxurist": luxurist,
+        "mechanician": mechanician,
+        "nonbookish": nonbookish,
+        "Onopordon": onopordon,
+        "podgily": podgily,
+        "reformableness": reformableness,
+        "scatterbrains": scatterbrains,
+        "seminuria": seminuria,
+        "Sodomite": sodomite,
+        "tramp": tramp,
+        "undueness": undueness,
+        "worthily": worthily,
+        "Yankeeist": yankeeist,
+    };
+}
+
+class TruantcyClass {
+    final dynamic alfiona;
+    final dynamic ascaridiasis;
+    final dynamic bungey;
+    final double? catharticalness;
+    final dynamic ceroxyle;
+    final int? chirotherium;
+    final dynamic chorology;
+    final String? disdiapason;
+    final dynamic enmarble;
+    final dynamic epeira;
+    final dynamic eurylaimi;
+    final dynamic germination;
+    final dynamic hallelujah;
+    final bool? homocerc;
+    final dynamic lev;
+    final dynamic mouthing;
+    final dynamic nonbookish;
+    final dynamic philliloo;
+    final dynamic planetal;
+    final dynamic poney;
+    final dynamic punctualist;
+    final dynamic returnlessly;
+    final dynamic skelder;
+    final dynamic windwaywardly;
+    final dynamic yuman;
+
+    TruantcyClass({
+        this.alfiona,
+        this.ascaridiasis,
+        this.bungey,
+        this.catharticalness,
+        this.ceroxyle,
+        this.chirotherium,
+        this.chorology,
+        this.disdiapason,
+        this.enmarble,
+        this.epeira,
+        this.eurylaimi,
+        this.germination,
+        this.hallelujah,
+        this.homocerc,
+        this.lev,
+        this.mouthing,
+        this.nonbookish,
+        this.philliloo,
+        this.planetal,
+        this.poney,
+        this.punctualist,
+        this.returnlessly,
+        this.skelder,
+        this.windwaywardly,
+        this.yuman,
+    });
+
+    factory TruantcyClass.fromJson(Map<String, dynamic> json) => TruantcyClass(
+        alfiona: json["alfiona"],
+        ascaridiasis: json["ascaridiasis"],
+        bungey: json["bungey"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        ceroxyle: json["ceroxyle"],
+        chirotherium: json["Chirotherium"],
+        chorology: json["chorology"],
+        disdiapason: json["disdiapason"],
+        enmarble: json["enmarble"],
+        epeira: json["Epeira"],
+        eurylaimi: json["Eurylaimi"],
+        germination: json["germination"],
+        hallelujah: json["hallelujah"],
+        homocerc: json["homocerc"],
+        lev: json["lev"],
+        mouthing: json["mouthing"],
+        nonbookish: json["nonbookish"],
+        philliloo: json["philliloo"],
+        planetal: json["planetal"],
+        poney: json["poney"],
+        punctualist: json["punctualist"],
+        returnlessly: json["returnlessly"],
+        skelder: json["skelder"],
+        windwaywardly: json["windwaywardly"],
+        yuman: json["Yuman"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "alfiona": alfiona,
+        "ascaridiasis": ascaridiasis,
+        "bungey": bungey,
+        "catharticalness": catharticalness,
+        "ceroxyle": ceroxyle,
+        "Chirotherium": chirotherium,
+        "chorology": chorology,
+        "disdiapason": disdiapason,
+        "enmarble": enmarble,
+        "Epeira": epeira,
+        "Eurylaimi": eurylaimi,
+        "germination": germination,
+        "hallelujah": hallelujah,
+        "homocerc": homocerc,
+        "lev": lev,
+        "mouthing": mouthing,
+        "nonbookish": nonbookish,
+        "philliloo": philliloo,
+        "planetal": planetal,
+        "poney": poney,
+        "punctualist": punctualist,
+        "returnlessly": returnlessly,
+        "skelder": skelder,
+        "windwaywardly": windwaywardly,
+        "Yuman": yuman,
+    };
+}
+
+class UnimpeachablyClass {
+    final int? acerin;
+    final int? bobadil;
+    final double? catharticalness;
+    final int? chirotherium;
+    final int? chlorophylligenous;
+    final int? conversational;
+    final int? demiowl;
+    final String? disdiapason;
+    final int? ectorhinal;
+    final int? gamblesomeness;
+    final bool? homocerc;
+    final int? irrorate;
+    final int? kindergartening;
+    final int? lateritic;
+    final int? mespil;
+    final int? misconfiguration;
+    final dynamic nonbookish;
+    final int? planometry;
+    final int? quiina;
+    final int? robert;
+    final int? rot;
+    final int? subcinctorium;
+    final int? tussocker;
+    final int? ultraproud;
+    final int? unsuggestedness;
+
+    UnimpeachablyClass({
+        this.acerin,
+        this.bobadil,
+        this.catharticalness,
+        this.chirotherium,
+        this.chlorophylligenous,
+        this.conversational,
+        this.demiowl,
+        this.disdiapason,
+        this.ectorhinal,
+        this.gamblesomeness,
+        this.homocerc,
+        this.irrorate,
+        this.kindergartening,
+        this.lateritic,
+        this.mespil,
+        this.misconfiguration,
+        this.nonbookish,
+        this.planometry,
+        this.quiina,
+        this.robert,
+        this.rot,
+        this.subcinctorium,
+        this.tussocker,
+        this.ultraproud,
+        this.unsuggestedness,
+    });
+
+    factory UnimpeachablyClass.fromJson(Map<String, dynamic> json) => UnimpeachablyClass(
+        acerin: json["acerin"],
+        bobadil: json["Bobadil"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chlorophylligenous: json["chlorophylligenous"],
+        conversational: json["conversational"],
+        demiowl: json["demiowl"],
+        disdiapason: json["disdiapason"],
+        ectorhinal: json["ectorhinal"],
+        gamblesomeness: json["gamblesomeness"],
+        homocerc: json["homocerc"],
+        irrorate: json["irrorate"],
+        kindergartening: json["kindergartening"],
+        lateritic: json["lateritic"],
+        mespil: json["mespil"],
+        misconfiguration: json["misconfiguration"],
+        nonbookish: json["nonbookish"],
+        planometry: json["planometry"],
+        quiina: json["Quiina"],
+        robert: json["Robert"],
+        rot: json["rot"],
+        subcinctorium: json["subcinctorium"],
+        tussocker: json["tussocker"],
+        ultraproud: json["ultraproud"],
+        unsuggestedness: json["unsuggestedness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "acerin": acerin,
+        "Bobadil": bobadil,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "chlorophylligenous": chlorophylligenous,
+        "conversational": conversational,
+        "demiowl": demiowl,
+        "disdiapason": disdiapason,
+        "ectorhinal": ectorhinal,
+        "gamblesomeness": gamblesomeness,
+        "homocerc": homocerc,
+        "irrorate": irrorate,
+        "kindergartening": kindergartening,
+        "lateritic": lateritic,
+        "mespil": mespil,
+        "misconfiguration": misconfiguration,
+        "nonbookish": nonbookish,
+        "planometry": planometry,
+        "Quiina": quiina,
+        "Robert": robert,
+        "rot": rot,
+        "subcinctorium": subcinctorium,
+        "tussocker": tussocker,
+        "ultraproud": ultraproud,
+        "unsuggestedness": unsuggestedness,
+    };
+}
+
+class UnstressedClass {
+    final dynamic alain;
+    final dynamic amphirhina;
+    final dynamic antimachinery;
+    final dynamic coldish;
+    final dynamic crantara;
+    final dynamic distinguishing;
+    final dynamic elytroposis;
+    final dynamic gentianwort;
+    final dynamic heliosis;
+    final dynamic instrumental;
+    final dynamic introinflection;
+    final dynamic kala;
+    final dynamic lincolnian;
+    final dynamic metad;
+    final dynamic sarcophilus;
+    final dynamic swingingly;
+    final dynamic unconformity;
+    final dynamic undecreed;
+    final dynamic venerable;
+    final dynamic vowellessness;
+
+    UnstressedClass({
+        required this.alain,
+        required this.amphirhina,
+        required this.antimachinery,
+        required this.coldish,
+        required this.crantara,
+        required this.distinguishing,
+        required this.elytroposis,
+        required this.gentianwort,
+        required this.heliosis,
+        required this.instrumental,
+        required this.introinflection,
+        required this.kala,
+        required this.lincolnian,
+        required this.metad,
+        required this.sarcophilus,
+        required this.swingingly,
+        required this.unconformity,
+        required this.undecreed,
+        required this.venerable,
+        required this.vowellessness,
+    });
+
+    factory UnstressedClass.fromJson(Map<String, dynamic> json) => UnstressedClass(
+        alain: json["Alain"],
+        amphirhina: json["Amphirhina"],
+        antimachinery: json["antimachinery"],
+        coldish: json["coldish"],
+        crantara: json["crantara"],
+        distinguishing: json["distinguishing"],
+        elytroposis: json["elytroposis"],
+        gentianwort: json["gentianwort"],
+        heliosis: json["heliosis"],
+        instrumental: json["instrumental"],
+        introinflection: json["introinflection"],
+        kala: json["kala"],
+        lincolnian: json["Lincolnian"],
+        metad: json["metad"],
+        sarcophilus: json["Sarcophilus"],
+        swingingly: json["swingingly"],
+        unconformity: json["unconformity"],
+        undecreed: json["undecreed"],
+        venerable: json["venerable"],
+        vowellessness: json["vowellessness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Alain": alain,
+        "Amphirhina": amphirhina,
+        "antimachinery": antimachinery,
+        "coldish": coldish,
+        "crantara": crantara,
+        "distinguishing": distinguishing,
+        "elytroposis": elytroposis,
+        "gentianwort": gentianwort,
+        "heliosis": heliosis,
+        "instrumental": instrumental,
+        "introinflection": introinflection,
+        "kala": kala,
+        "Lincolnian": lincolnian,
+        "metad": metad,
+        "Sarcophilus": sarcophilus,
+        "swingingly": swingingly,
+        "unconformity": unconformity,
+        "undecreed": undecreed,
+        "venerable": venerable,
+        "vowellessness": vowellessness,
+    };
+}
+
+class WrothyClass {
+    final dynamic aeschynanthus;
+    final dynamic aquiferous;
+    final dynamic cheapener;
+    final dynamic enumeration;
+    final dynamic ephesine;
+    final dynamic escadrille;
+    final dynamic estrous;
+    final dynamic interestedly;
+    final dynamic katakinetomer;
+    final dynamic mortification;
+    final dynamic morula;
+    final dynamic orthosymmetrical;
+    final dynamic overbark;
+    final dynamic politist;
+    final dynamic qualified;
+    final dynamic sphenomalar;
+    final dynamic throatful;
+    final dynamic transhumance;
+    final dynamic triandrian;
+    final dynamic unbooked;
+
+    WrothyClass({
+        required this.aeschynanthus,
+        required this.aquiferous,
+        required this.cheapener,
+        required this.enumeration,
+        required this.ephesine,
+        required this.escadrille,
+        required this.estrous,
+        required this.interestedly,
+        required this.katakinetomer,
+        required this.mortification,
+        required this.morula,
+        required this.orthosymmetrical,
+        required this.overbark,
+        required this.politist,
+        required this.qualified,
+        required this.sphenomalar,
+        required this.throatful,
+        required this.transhumance,
+        required this.triandrian,
+        required this.unbooked,
+    });
+
+    factory WrothyClass.fromJson(Map<String, dynamic> json) => WrothyClass(
+        aeschynanthus: json["Aeschynanthus"],
+        aquiferous: json["aquiferous"],
+        cheapener: json["cheapener"],
+        enumeration: json["enumeration"],
+        ephesine: json["Ephesine"],
+        escadrille: json["escadrille"],
+        estrous: json["estrous"],
+        interestedly: json["interestedly"],
+        katakinetomer: json["katakinetomer"],
+        mortification: json["mortification"],
+        morula: json["morula"],
+        orthosymmetrical: json["orthosymmetrical"],
+        overbark: json["overbark"],
+        politist: json["politist"],
+        qualified: json["qualified"],
+        sphenomalar: json["sphenomalar"],
+        throatful: json["throatful"],
+        transhumance: json["transhumance"],
+        triandrian: json["triandrian"],
+        unbooked: json["unbooked"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Aeschynanthus": aeschynanthus,
+        "aquiferous": aquiferous,
+        "cheapener": cheapener,
+        "enumeration": enumeration,
+        "Ephesine": ephesine,
+        "escadrille": escadrille,
+        "estrous": estrous,
+        "interestedly": interestedly,
+        "katakinetomer": katakinetomer,
+        "mortification": mortification,
+        "morula": morula,
+        "orthosymmetrical": orthosymmetrical,
+        "overbark": overbark,
+        "politist": politist,
+        "qualified": qualified,
+        "sphenomalar": sphenomalar,
+        "throatful": throatful,
+        "transhumance": transhumance,
+        "triandrian": triandrian,
+        "unbooked": unbooked,
+    };
+}
diff --git a/head/dart/test/inputs/json/priority/combinations4.json/final-props-false--58a791807e0c/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations4.json/final-props-false--58a791807e0c/TopLevel.dart
new file mode 100644
index 0000000..dbdb05d
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/combinations4.json/final-props-false--58a791807e0c/TopLevel.dart
@@ -0,0 +1,1761 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    List<dynamic> protrusive;
+    List<dynamic> pulpitism;
+    List<dynamic> pyodermia;
+    List<dynamic> quebrachine;
+    List<dynamic> querier;
+    List<dynamic> rebarbative;
+    List<Reimagine> reimagine;
+    Ressaut ressaut;
+    List<dynamic> retrocervical;
+    List<dynamic> revert;
+    List<dynamic> rewrite;
+    List<dynamic> saccoderm;
+    List<dynamic> santir;
+    List<dynamic> saprophilous;
+    List<dynamic> saxten;
+    List<Scatty?> scatty;
+    List<dynamic> scoffer;
+    List<dynamic> scrampum;
+    double semantic;
+    List<dynamic> serpentinic;
+    List<dynamic> shadowable;
+    List<dynamic> sistering;
+    List<Staghunting> staghunting;
+    List<dynamic> stagmometer;
+    List<dynamic> stimulability;
+    List<dynamic> strangleable;
+    List<dynamic> strenuosity;
+    List<dynamic> tabaxir;
+    List<dynamic> talpiform;
+    List<dynamic> thwack;
+    List<double?> to;
+    List<dynamic> tortricine;
+    List<dynamic> truantcy;
+    List<String> turgesce;
+    List<dynamic> unbeginning;
+    List<double> underdunged;
+    List<dynamic> undesirability;
+    List<dynamic> unerasing;
+    List<dynamic> unguentarium;
+    List<dynamic> unimpeachably;
+    List<dynamic> unmortgaged;
+    List<dynamic> unobstructed;
+    List<dynamic> unreceptivity;
+    List<dynamic> unsatisfactoriness;
+    List<int> unsecurity;
+    List<dynamic> unstressed;
+    List<dynamic> untasked;
+    List<dynamic> unvarying;
+    List<dynamic> vehemently;
+    Map<String, bool> warriorship;
+    List<dynamic> whitepot;
+    List<dynamic> wrothy;
+
+    TopLevel({
+        required this.protrusive,
+        required this.pulpitism,
+        required this.pyodermia,
+        required this.quebrachine,
+        required this.querier,
+        required this.rebarbative,
+        required this.reimagine,
+        required this.ressaut,
+        required this.retrocervical,
+        required this.revert,
+        required this.rewrite,
+        required this.saccoderm,
+        required this.santir,
+        required this.saprophilous,
+        required this.saxten,
+        required this.scatty,
+        required this.scoffer,
+        required this.scrampum,
+        required this.semantic,
+        required this.serpentinic,
+        required this.shadowable,
+        required this.sistering,
+        required this.staghunting,
+        required this.stagmometer,
+        required this.stimulability,
+        required this.strangleable,
+        required this.strenuosity,
+        required this.tabaxir,
+        required this.talpiform,
+        required this.thwack,
+        required this.to,
+        required this.tortricine,
+        required this.truantcy,
+        required this.turgesce,
+        required this.unbeginning,
+        required this.underdunged,
+        required this.undesirability,
+        required this.unerasing,
+        required this.unguentarium,
+        required this.unimpeachably,
+        required this.unmortgaged,
+        required this.unobstructed,
+        required this.unreceptivity,
+        required this.unsatisfactoriness,
+        required this.unsecurity,
+        required this.unstressed,
+        required this.untasked,
+        required this.unvarying,
+        required this.vehemently,
+        required this.warriorship,
+        required this.whitepot,
+        required this.wrothy,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        protrusive: List<dynamic>.from(json["protrusive"].map((x) => x)),
+        pulpitism: List<dynamic>.from(json["pulpitism"].map((x) => x)),
+        pyodermia: List<dynamic>.from(json["pyodermia"].map((x) => x)),
+        quebrachine: List<dynamic>.from(json["quebrachine"].map((x) => x)),
+        querier: List<dynamic>.from(json["querier"].map((x) => x)),
+        rebarbative: List<dynamic>.from(json["rebarbative"].map((x) => x)),
+        reimagine: List<Reimagine>.from(json["reimagine"].map((x) => Reimagine.fromJson(x))),
+        ressaut: Ressaut.fromJson(json["ressaut"]),
+        retrocervical: List<dynamic>.from(json["retrocervical"].map((x) => x)),
+        revert: List<dynamic>.from(json["revert"].map((x) => x)),
+        rewrite: List<dynamic>.from(json["rewrite"].map((x) => x)),
+        saccoderm: List<dynamic>.from(json["saccoderm"].map((x) => x)),
+        santir: List<dynamic>.from(json["santir"].map((x) => x)),
+        saprophilous: List<dynamic>.from(json["saprophilous"].map((x) => x)),
+        saxten: List<dynamic>.from(json["saxten"].map((x) => x)),
+        scatty: List<Scatty?>.from(json["scatty"].map((x) => x == null ? null : Scatty.fromJson(x))),
+        scoffer: List<dynamic>.from(json["scoffer"].map((x) => x)),
+        scrampum: List<dynamic>.from(json["scrampum"].map((x) => x)),
+        semantic: json["semantic"]?.toDouble(),
+        serpentinic: List<dynamic>.from(json["serpentinic"].map((x) => x)),
+        shadowable: List<dynamic>.from(json["shadowable"].map((x) => x)),
+        sistering: List<dynamic>.from(json["sistering"].map((x) => x)),
+        staghunting: List<Staghunting>.from(json["staghunting"].map((x) => Staghunting.fromJson(x))),
+        stagmometer: List<dynamic>.from(json["stagmometer"].map((x) => x)),
+        stimulability: List<dynamic>.from(json["stimulability"].map((x) => x)),
+        strangleable: List<dynamic>.from(json["strangleable"].map((x) => x)),
+        strenuosity: List<dynamic>.from(json["strenuosity"].map((x) => x)),
+        tabaxir: List<dynamic>.from(json["tabaxir"].map((x) => x)),
+        talpiform: List<dynamic>.from(json["talpiform"].map((x) => x)),
+        thwack: List<dynamic>.from(json["thwack"].map((x) => x)),
+        to: List<double?>.from(json["to"].map((x) => x?.toDouble())),
+        tortricine: List<dynamic>.from(json["tortricine"].map((x) => x)),
+        truantcy: List<dynamic>.from(json["truantcy"].map((x) => x)),
+        turgesce: List<String>.from(json["turgesce"].map((x) => x)),
+        unbeginning: List<dynamic>.from(json["unbeginning"].map((x) => x)),
+        underdunged: List<double>.from(json["underdunged"].map((x) => x?.toDouble())),
+        undesirability: List<dynamic>.from(json["undesirability"].map((x) => x)),
+        unerasing: List<dynamic>.from(json["unerasing"].map((x) => x)),
+        unguentarium: List<dynamic>.from(json["unguentarium"].map((x) => x)),
+        unimpeachably: List<dynamic>.from(json["unimpeachably"].map((x) => x)),
+        unmortgaged: List<dynamic>.from(json["unmortgaged"].map((x) => x)),
+        unobstructed: List<dynamic>.from(json["unobstructed"].map((x) => x)),
+        unreceptivity: List<dynamic>.from(json["unreceptivity"].map((x) => x)),
+        unsatisfactoriness: List<dynamic>.from(json["unsatisfactoriness"].map((x) => x)),
+        unsecurity: List<int>.from(json["unsecurity"].map((x) => x)),
+        unstressed: List<dynamic>.from(json["unstressed"].map((x) => x)),
+        untasked: List<dynamic>.from(json["untasked"].map((x) => x)),
+        unvarying: List<dynamic>.from(json["unvarying"].map((x) => x)),
+        vehemently: List<dynamic>.from(json["vehemently"].map((x) => x)),
+        warriorship: Map.from(json["warriorship"]).map((k, v) => MapEntry<String, bool>(k, v)),
+        whitepot: List<dynamic>.from(json["whitepot"].map((x) => x)),
+        wrothy: List<dynamic>.from(json["wrothy"].map((x) => x)),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "protrusive": List<dynamic>.from(protrusive.map((x) => x)),
+        "pulpitism": List<dynamic>.from(pulpitism.map((x) => x)),
+        "pyodermia": List<dynamic>.from(pyodermia.map((x) => x)),
+        "quebrachine": List<dynamic>.from(quebrachine.map((x) => x)),
+        "querier": List<dynamic>.from(querier.map((x) => x)),
+        "rebarbative": List<dynamic>.from(rebarbative.map((x) => x)),
+        "reimagine": List<dynamic>.from(reimagine.map((x) => x.toJson())),
+        "ressaut": ressaut.toJson(),
+        "retrocervical": List<dynamic>.from(retrocervical.map((x) => x)),
+        "revert": List<dynamic>.from(revert.map((x) => x)),
+        "rewrite": List<dynamic>.from(rewrite.map((x) => x)),
+        "saccoderm": List<dynamic>.from(saccoderm.map((x) => x)),
+        "santir": List<dynamic>.from(santir.map((x) => x)),
+        "saprophilous": List<dynamic>.from(saprophilous.map((x) => x)),
+        "saxten": List<dynamic>.from(saxten.map((x) => x)),
+        "scatty": List<dynamic>.from(scatty.map((x) => x?.toJson())),
+        "scoffer": List<dynamic>.from(scoffer.map((x) => x)),
+        "scrampum": List<dynamic>.from(scrampum.map((x) => x)),
+        "semantic": semantic,
+        "serpentinic": List<dynamic>.from(serpentinic.map((x) => x)),
+        "shadowable": List<dynamic>.from(shadowable.map((x) => x)),
+        "sistering": List<dynamic>.from(sistering.map((x) => x)),
+        "staghunting": List<dynamic>.from(staghunting.map((x) => x.toJson())),
+        "stagmometer": List<dynamic>.from(stagmometer.map((x) => x)),
+        "stimulability": List<dynamic>.from(stimulability.map((x) => x)),
+        "strangleable": List<dynamic>.from(strangleable.map((x) => x)),
+        "strenuosity": List<dynamic>.from(strenuosity.map((x) => x)),
+        "tabaxir": List<dynamic>.from(tabaxir.map((x) => x)),
+        "talpiform": List<dynamic>.from(talpiform.map((x) => x)),
+        "thwack": List<dynamic>.from(thwack.map((x) => x)),
+        "to": List<dynamic>.from(to.map((x) => x)),
+        "tortricine": List<dynamic>.from(tortricine.map((x) => x)),
+        "truantcy": List<dynamic>.from(truantcy.map((x) => x)),
+        "turgesce": List<dynamic>.from(turgesce.map((x) => x)),
+        "unbeginning": List<dynamic>.from(unbeginning.map((x) => x)),
+        "underdunged": List<dynamic>.from(underdunged.map((x) => x)),
+        "undesirability": List<dynamic>.from(undesirability.map((x) => x)),
+        "unerasing": List<dynamic>.from(unerasing.map((x) => x)),
+        "unguentarium": List<dynamic>.from(unguentarium.map((x) => x)),
+        "unimpeachably": List<dynamic>.from(unimpeachably.map((x) => x)),
+        "unmortgaged": List<dynamic>.from(unmortgaged.map((x) => x)),
+        "unobstructed": List<dynamic>.from(unobstructed.map((x) => x)),
+        "unreceptivity": List<dynamic>.from(unreceptivity.map((x) => x)),
+        "unsatisfactoriness": List<dynamic>.from(unsatisfactoriness.map((x) => x)),
+        "unsecurity": List<dynamic>.from(unsecurity.map((x) => x)),
+        "unstressed": List<dynamic>.from(unstressed.map((x) => x)),
+        "untasked": List<dynamic>.from(untasked.map((x) => x)),
+        "unvarying": List<dynamic>.from(unvarying.map((x) => x)),
+        "vehemently": List<dynamic>.from(vehemently.map((x) => x)),
+        "warriorship": Map.from(warriorship).map((k, v) => MapEntry<String, dynamic>(k, v)),
+        "whitepot": List<dynamic>.from(whitepot.map((x) => x)),
+        "wrothy": List<dynamic>.from(wrothy.map((x) => x)),
+    };
+}
+
+class PulpitismClass {
+    dynamic abnet;
+    dynamic buckhorn;
+    dynamic calciform;
+    dynamic chelophore;
+    dynamic cogitation;
+    dynamic decreeable;
+    dynamic despicable;
+    dynamic isodiazo;
+    dynamic jadedly;
+    dynamic leptochlorite;
+    dynamic nursling;
+    dynamic palamedean;
+    dynamic photoheliograph;
+    dynamic pipewood;
+    dynamic roberd;
+    dynamic statable;
+    dynamic superassume;
+    dynamic syllabe;
+    dynamic toughhead;
+    dynamic underburn;
+
+    PulpitismClass({
+        required this.abnet,
+        required this.buckhorn,
+        required this.calciform,
+        required this.chelophore,
+        required this.cogitation,
+        required this.decreeable,
+        required this.despicable,
+        required this.isodiazo,
+        required this.jadedly,
+        required this.leptochlorite,
+        required this.nursling,
+        required this.palamedean,
+        required this.photoheliograph,
+        required this.pipewood,
+        required this.roberd,
+        required this.statable,
+        required this.superassume,
+        required this.syllabe,
+        required this.toughhead,
+        required this.underburn,
+    });
+
+    factory PulpitismClass.fromJson(Map<String, dynamic> json) => PulpitismClass(
+        abnet: json["abnet"],
+        buckhorn: json["buckhorn"],
+        calciform: json["calciform"],
+        chelophore: json["chelophore"],
+        cogitation: json["cogitation"],
+        decreeable: json["decreeable"],
+        despicable: json["despicable"],
+        isodiazo: json["isodiazo"],
+        jadedly: json["jadedly"],
+        leptochlorite: json["leptochlorite"],
+        nursling: json["nursling"],
+        palamedean: json["palamedean"],
+        photoheliograph: json["photoheliograph"],
+        pipewood: json["pipewood"],
+        roberd: json["roberd"],
+        statable: json["statable"],
+        superassume: json["superassume"],
+        syllabe: json["syllabe"],
+        toughhead: json["toughhead"],
+        underburn: json["underburn"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "abnet": abnet,
+        "buckhorn": buckhorn,
+        "calciform": calciform,
+        "chelophore": chelophore,
+        "cogitation": cogitation,
+        "decreeable": decreeable,
+        "despicable": despicable,
+        "isodiazo": isodiazo,
+        "jadedly": jadedly,
+        "leptochlorite": leptochlorite,
+        "nursling": nursling,
+        "palamedean": palamedean,
+        "photoheliograph": photoheliograph,
+        "pipewood": pipewood,
+        "roberd": roberd,
+        "statable": statable,
+        "superassume": superassume,
+        "syllabe": syllabe,
+        "toughhead": toughhead,
+        "underburn": underburn,
+    };
+}
+
+class PyodermiaClass {
+    dynamic aphoristically;
+    dynamic apophyllous;
+    dynamic cognize;
+    dynamic dermonosology;
+    dynamic gyppo;
+    dynamic ither;
+    dynamic juglandaceous;
+    dynamic litho;
+    dynamic macropterous;
+    dynamic photographer;
+    dynamic romancing;
+    dynamic rumness;
+    dynamic somniloquist;
+    dynamic stressfully;
+    dynamic tactically;
+    dynamic tracheophony;
+    dynamic unappositely;
+    dynamic unclothedly;
+    dynamic unimplied;
+    dynamic unsyncopated;
+
+    PyodermiaClass({
+        required this.aphoristically,
+        required this.apophyllous,
+        required this.cognize,
+        required this.dermonosology,
+        required this.gyppo,
+        required this.ither,
+        required this.juglandaceous,
+        required this.litho,
+        required this.macropterous,
+        required this.photographer,
+        required this.romancing,
+        required this.rumness,
+        required this.somniloquist,
+        required this.stressfully,
+        required this.tactically,
+        required this.tracheophony,
+        required this.unappositely,
+        required this.unclothedly,
+        required this.unimplied,
+        required this.unsyncopated,
+    });
+
+    factory PyodermiaClass.fromJson(Map<String, dynamic> json) => PyodermiaClass(
+        aphoristically: json["aphoristically"],
+        apophyllous: json["apophyllous"],
+        cognize: json["cognize"],
+        dermonosology: json["dermonosology"],
+        gyppo: json["Gyppo"],
+        ither: json["ither"],
+        juglandaceous: json["juglandaceous"],
+        litho: json["litho"],
+        macropterous: json["macropterous"],
+        photographer: json["photographer"],
+        romancing: json["romancing"],
+        rumness: json["rumness"],
+        somniloquist: json["somniloquist"],
+        stressfully: json["stressfully"],
+        tactically: json["tactically"],
+        tracheophony: json["tracheophony"],
+        unappositely: json["unappositely"],
+        unclothedly: json["unclothedly"],
+        unimplied: json["unimplied"],
+        unsyncopated: json["unsyncopated"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "aphoristically": aphoristically,
+        "apophyllous": apophyllous,
+        "cognize": cognize,
+        "dermonosology": dermonosology,
+        "Gyppo": gyppo,
+        "ither": ither,
+        "juglandaceous": juglandaceous,
+        "litho": litho,
+        "macropterous": macropterous,
+        "photographer": photographer,
+        "romancing": romancing,
+        "rumness": rumness,
+        "somniloquist": somniloquist,
+        "stressfully": stressfully,
+        "tactically": tactically,
+        "tracheophony": tracheophony,
+        "unappositely": unappositely,
+        "unclothedly": unclothedly,
+        "unimplied": unimplied,
+        "unsyncopated": unsyncopated,
+    };
+}
+
+class QuebrachineClass {
+    double catharticalness;
+    int chirotherium;
+    String disdiapason;
+    bool homocerc;
+    dynamic nonbookish;
+
+    QuebrachineClass({
+        required this.catharticalness,
+        required this.chirotherium,
+        required this.disdiapason,
+        required this.homocerc,
+        required this.nonbookish,
+    });
+
+    factory QuebrachineClass.fromJson(Map<String, dynamic> json) => QuebrachineClass(
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        homocerc: json["homocerc"],
+        nonbookish: json["nonbookish"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "homocerc": homocerc,
+        "nonbookish": nonbookish,
+    };
+}
+
+class Reimagine {
+    dynamic adducible;
+    dynamic anabolin;
+    dynamic brainy;
+    double? catharticalness;
+    int? chirotherium;
+    dynamic chrysamine;
+    String? disdiapason;
+    dynamic fluxweed;
+    dynamic glaucine;
+    dynamic grobianism;
+    dynamic hermo;
+    dynamic hieroglyphist;
+    bool? homocerc;
+    dynamic icteroid;
+    dynamic immortal;
+    dynamic impetulant;
+    dynamic irrigate;
+    dynamic myxedema;
+    dynamic nonbookish;
+    dynamic onyx;
+    dynamic repasser;
+    dynamic septomarginal;
+    dynamic subdie;
+    dynamic tibiometatarsal;
+    dynamic waltzlike;
+
+    Reimagine({
+        this.adducible,
+        this.anabolin,
+        this.brainy,
+        this.catharticalness,
+        this.chirotherium,
+        this.chrysamine,
+        this.disdiapason,
+        this.fluxweed,
+        this.glaucine,
+        this.grobianism,
+        this.hermo,
+        this.hieroglyphist,
+        this.homocerc,
+        this.icteroid,
+        this.immortal,
+        this.impetulant,
+        this.irrigate,
+        this.myxedema,
+        this.nonbookish,
+        this.onyx,
+        this.repasser,
+        this.septomarginal,
+        this.subdie,
+        this.tibiometatarsal,
+        this.waltzlike,
+    });
+
+    factory Reimagine.fromJson(Map<String, dynamic> json) => Reimagine(
+        adducible: json["adducible"],
+        anabolin: json["anabolin"],
+        brainy: json["brainy"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chrysamine: json["chrysamine"],
+        disdiapason: json["disdiapason"],
+        fluxweed: json["fluxweed"],
+        glaucine: json["glaucine"],
+        grobianism: json["grobianism"],
+        hermo: json["Hermo"],
+        hieroglyphist: json["hieroglyphist"],
+        homocerc: json["homocerc"],
+        icteroid: json["icteroid"],
+        immortal: json["immortal"],
+        impetulant: json["impetulant"],
+        irrigate: json["irrigate"],
+        myxedema: json["myxedema"],
+        nonbookish: json["nonbookish"],
+        onyx: json["onyx"],
+        repasser: json["repasser"],
+        septomarginal: json["septomarginal"],
+        subdie: json["subdie"],
+        tibiometatarsal: json["tibiometatarsal"],
+        waltzlike: json["waltzlike"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "adducible": adducible,
+        "anabolin": anabolin,
+        "brainy": brainy,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "chrysamine": chrysamine,
+        "disdiapason": disdiapason,
+        "fluxweed": fluxweed,
+        "glaucine": glaucine,
+        "grobianism": grobianism,
+        "Hermo": hermo,
+        "hieroglyphist": hieroglyphist,
+        "homocerc": homocerc,
+        "icteroid": icteroid,
+        "immortal": immortal,
+        "impetulant": impetulant,
+        "irrigate": irrigate,
+        "myxedema": myxedema,
+        "nonbookish": nonbookish,
+        "onyx": onyx,
+        "repasser": repasser,
+        "septomarginal": septomarginal,
+        "subdie": subdie,
+        "tibiometatarsal": tibiometatarsal,
+        "waltzlike": waltzlike,
+    };
+}
+
+class Ressaut {
+    String apperceptive;
+    String cuttoo;
+    String douser;
+    String drinkproof;
+    String forementioned;
+    String freesia;
+    String genevieve;
+    String hyperdiabolical;
+    String hypocone;
+    String irreverentially;
+    String jumart;
+    String mimosaceae;
+    String mollicrush;
+    String nedder;
+    String retinasphalt;
+    String sough;
+    String steading;
+    String theopaschitism;
+    String undurableness;
+    String unmingleable;
+
+    Ressaut({
+        required this.apperceptive,
+        required this.cuttoo,
+        required this.douser,
+        required this.drinkproof,
+        required this.forementioned,
+        required this.freesia,
+        required this.genevieve,
+        required this.hyperdiabolical,
+        required this.hypocone,
+        required this.irreverentially,
+        required this.jumart,
+        required this.mimosaceae,
+        required this.mollicrush,
+        required this.nedder,
+        required this.retinasphalt,
+        required this.sough,
+        required this.steading,
+        required this.theopaschitism,
+        required this.undurableness,
+        required this.unmingleable,
+    });
+
+    factory Ressaut.fromJson(Map<String, dynamic> json) => Ressaut(
+        apperceptive: json["apperceptive"],
+        cuttoo: json["cuttoo"],
+        douser: json["douser"],
+        drinkproof: json["drinkproof"],
+        forementioned: json["forementioned"],
+        freesia: json["Freesia"],
+        genevieve: json["Genevieve"],
+        hyperdiabolical: json["hyperdiabolical"],
+        hypocone: json["hypocone"],
+        irreverentially: json["irreverentially"],
+        jumart: json["jumart"],
+        mimosaceae: json["Mimosaceae"],
+        mollicrush: json["mollicrush"],
+        nedder: json["nedder"],
+        retinasphalt: json["retinasphalt"],
+        sough: json["sough"],
+        steading: json["steading"],
+        theopaschitism: json["Theopaschitism"],
+        undurableness: json["undurableness"],
+        unmingleable: json["unmingleable"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "apperceptive": apperceptive,
+        "cuttoo": cuttoo,
+        "douser": douser,
+        "drinkproof": drinkproof,
+        "forementioned": forementioned,
+        "Freesia": freesia,
+        "Genevieve": genevieve,
+        "hyperdiabolical": hyperdiabolical,
+        "hypocone": hypocone,
+        "irreverentially": irreverentially,
+        "jumart": jumart,
+        "Mimosaceae": mimosaceae,
+        "mollicrush": mollicrush,
+        "nedder": nedder,
+        "retinasphalt": retinasphalt,
+        "sough": sough,
+        "steading": steading,
+        "Theopaschitism": theopaschitism,
+        "undurableness": undurableness,
+        "unmingleable": unmingleable,
+    };
+}
+
+class RewriteClass {
+    dynamic accountancy;
+    dynamic cacotrophic;
+    dynamic contest;
+    dynamic couthily;
+    dynamic falculate;
+    dynamic foreseize;
+    dynamic hyades;
+    dynamic lemnad;
+    dynamic monotheistically;
+    dynamic nonflying;
+    dynamic ptenoglossa;
+    dynamic repatch;
+    dynamic rodman;
+    dynamic strung;
+    dynamic titmal;
+    dynamic twalpennyworth;
+    dynamic unblamable;
+    dynamic vertical;
+    dynamic whiggification;
+    dynamic yardman;
+
+    RewriteClass({
+        required this.accountancy,
+        required this.cacotrophic,
+        required this.contest,
+        required this.couthily,
+        required this.falculate,
+        required this.foreseize,
+        required this.hyades,
+        required this.lemnad,
+        required this.monotheistically,
+        required this.nonflying,
+        required this.ptenoglossa,
+        required this.repatch,
+        required this.rodman,
+        required this.strung,
+        required this.titmal,
+        required this.twalpennyworth,
+        required this.unblamable,
+        required this.vertical,
+        required this.whiggification,
+        required this.yardman,
+    });
+
+    factory RewriteClass.fromJson(Map<String, dynamic> json) => RewriteClass(
+        accountancy: json["accountancy"],
+        cacotrophic: json["cacotrophic"],
+        contest: json["contest"],
+        couthily: json["couthily"],
+        falculate: json["falculate"],
+        foreseize: json["foreseize"],
+        hyades: json["Hyades"],
+        lemnad: json["lemnad"],
+        monotheistically: json["monotheistically"],
+        nonflying: json["nonflying"],
+        ptenoglossa: json["Ptenoglossa"],
+        repatch: json["repatch"],
+        rodman: json["rodman"],
+        strung: json["strung"],
+        titmal: json["titmal"],
+        twalpennyworth: json["twalpennyworth"],
+        unblamable: json["unblamable"],
+        vertical: json["vertical"],
+        whiggification: json["Whiggification"],
+        yardman: json["yardman"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "accountancy": accountancy,
+        "cacotrophic": cacotrophic,
+        "contest": contest,
+        "couthily": couthily,
+        "falculate": falculate,
+        "foreseize": foreseize,
+        "Hyades": hyades,
+        "lemnad": lemnad,
+        "monotheistically": monotheistically,
+        "nonflying": nonflying,
+        "Ptenoglossa": ptenoglossa,
+        "repatch": repatch,
+        "rodman": rodman,
+        "strung": strung,
+        "titmal": titmal,
+        "twalpennyworth": twalpennyworth,
+        "unblamable": unblamable,
+        "vertical": vertical,
+        "Whiggification": whiggification,
+        "yardman": yardman,
+    };
+}
+
+class SantirClass {
+    dynamic admiredly;
+    dynamic demicaponier;
+    dynamic epitympanic;
+    dynamic investitor;
+    dynamic lupiform;
+    dynamic monoflagellate;
+    dynamic paleoethnic;
+    dynamic prediscountable;
+    dynamic rhetoricals;
+    dynamic roomth;
+    dynamic saccharose;
+    dynamic septonasal;
+    dynamic serpenticide;
+    dynamic setarious;
+    dynamic spaework;
+    dynamic stylite;
+    dynamic suessiones;
+    dynamic timelily;
+    dynamic unprofaned;
+    dynamic vorticular;
+
+    SantirClass({
+        required this.admiredly,
+        required this.demicaponier,
+        required this.epitympanic,
+        required this.investitor,
+        required this.lupiform,
+        required this.monoflagellate,
+        required this.paleoethnic,
+        required this.prediscountable,
+        required this.rhetoricals,
+        required this.roomth,
+        required this.saccharose,
+        required this.septonasal,
+        required this.serpenticide,
+        required this.setarious,
+        required this.spaework,
+        required this.stylite,
+        required this.suessiones,
+        required this.timelily,
+        required this.unprofaned,
+        required this.vorticular,
+    });
+
+    factory SantirClass.fromJson(Map<String, dynamic> json) => SantirClass(
+        admiredly: json["admiredly"],
+        demicaponier: json["demicaponier"],
+        epitympanic: json["epitympanic"],
+        investitor: json["investitor"],
+        lupiform: json["lupiform"],
+        monoflagellate: json["monoflagellate"],
+        paleoethnic: json["paleoethnic"],
+        prediscountable: json["prediscountable"],
+        rhetoricals: json["rhetoricals"],
+        roomth: json["roomth"],
+        saccharose: json["saccharose"],
+        septonasal: json["septonasal"],
+        serpenticide: json["serpenticide"],
+        setarious: json["setarious"],
+        spaework: json["spaework"],
+        stylite: json["stylite"],
+        suessiones: json["Suessiones"],
+        timelily: json["timelily"],
+        unprofaned: json["unprofaned"],
+        vorticular: json["vorticular"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "admiredly": admiredly,
+        "demicaponier": demicaponier,
+        "epitympanic": epitympanic,
+        "investitor": investitor,
+        "lupiform": lupiform,
+        "monoflagellate": monoflagellate,
+        "paleoethnic": paleoethnic,
+        "prediscountable": prediscountable,
+        "rhetoricals": rhetoricals,
+        "roomth": roomth,
+        "saccharose": saccharose,
+        "septonasal": septonasal,
+        "serpenticide": serpenticide,
+        "setarious": setarious,
+        "spaework": spaework,
+        "stylite": stylite,
+        "Suessiones": suessiones,
+        "timelily": timelily,
+        "unprofaned": unprofaned,
+        "vorticular": vorticular,
+    };
+}
+
+class SaxtenClass {
+    dynamic algarrobilla;
+    dynamic bowgrace;
+    double? catharticalness;
+    dynamic centaurid;
+    int? chirotherium;
+    String? disdiapason;
+    dynamic flix;
+    dynamic germanely;
+    bool? homocerc;
+    dynamic inhume;
+    dynamic lepidote;
+    dynamic megalochirous;
+    dynamic ninepenny;
+    dynamic nonbookish;
+    dynamic nondeist;
+    dynamic nymphaeaceous;
+    dynamic parietofrontal;
+    dynamic sancyite;
+    dynamic subjectivist;
+    dynamic tibiad;
+    dynamic transonic;
+    dynamic tripetalous;
+    dynamic trunchman;
+    dynamic urger;
+    dynamic withdrawnness;
+
+    SaxtenClass({
+        this.algarrobilla,
+        this.bowgrace,
+        this.catharticalness,
+        this.centaurid,
+        this.chirotherium,
+        this.disdiapason,
+        this.flix,
+        this.germanely,
+        this.homocerc,
+        this.inhume,
+        this.lepidote,
+        this.megalochirous,
+        this.ninepenny,
+        this.nonbookish,
+        this.nondeist,
+        this.nymphaeaceous,
+        this.parietofrontal,
+        this.sancyite,
+        this.subjectivist,
+        this.tibiad,
+        this.transonic,
+        this.tripetalous,
+        this.trunchman,
+        this.urger,
+        this.withdrawnness,
+    });
+
+    factory SaxtenClass.fromJson(Map<String, dynamic> json) => SaxtenClass(
+        algarrobilla: json["algarrobilla"],
+        bowgrace: json["bowgrace"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        centaurid: json["Centaurid"],
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        flix: json["flix"],
+        germanely: json["germanely"],
+        homocerc: json["homocerc"],
+        inhume: json["inhume"],
+        lepidote: json["lepidote"],
+        megalochirous: json["megalochirous"],
+        ninepenny: json["ninepenny"],
+        nonbookish: json["nonbookish"],
+        nondeist: json["nondeist"],
+        nymphaeaceous: json["nymphaeaceous"],
+        parietofrontal: json["parietofrontal"],
+        sancyite: json["sancyite"],
+        subjectivist: json["subjectivist"],
+        tibiad: json["tibiad"],
+        transonic: json["transonic"],
+        tripetalous: json["tripetalous"],
+        trunchman: json["trunchman"],
+        urger: json["urger"],
+        withdrawnness: json["withdrawnness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "algarrobilla": algarrobilla,
+        "bowgrace": bowgrace,
+        "catharticalness": catharticalness,
+        "Centaurid": centaurid,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "flix": flix,
+        "germanely": germanely,
+        "homocerc": homocerc,
+        "inhume": inhume,
+        "lepidote": lepidote,
+        "megalochirous": megalochirous,
+        "ninepenny": ninepenny,
+        "nonbookish": nonbookish,
+        "nondeist": nondeist,
+        "nymphaeaceous": nymphaeaceous,
+        "parietofrontal": parietofrontal,
+        "sancyite": sancyite,
+        "subjectivist": subjectivist,
+        "tibiad": tibiad,
+        "transonic": transonic,
+        "tripetalous": tripetalous,
+        "trunchman": trunchman,
+        "urger": urger,
+        "withdrawnness": withdrawnness,
+    };
+}
+
+class Scatty {
+    dynamic aeriferous;
+    dynamic antical;
+    dynamic antighostism;
+    dynamic arcanum;
+    dynamic autotrophy;
+    dynamic baronial;
+    dynamic caffeine;
+    dynamic gorgoniacean;
+    dynamic heroical;
+    dynamic hydropical;
+    dynamic mechanology;
+    dynamic musicopoetic;
+    dynamic officiality;
+    dynamic oftentimes;
+    dynamic ophthalmotonometer;
+    dynamic reflectively;
+    dynamic springer;
+    dynamic tabasco;
+    dynamic teleianthous;
+    dynamic uncombated;
+
+    Scatty({
+        required this.aeriferous,
+        required this.antical,
+        required this.antighostism,
+        required this.arcanum,
+        required this.autotrophy,
+        required this.baronial,
+        required this.caffeine,
+        required this.gorgoniacean,
+        required this.heroical,
+        required this.hydropical,
+        required this.mechanology,
+        required this.musicopoetic,
+        required this.officiality,
+        required this.oftentimes,
+        required this.ophthalmotonometer,
+        required this.reflectively,
+        required this.springer,
+        required this.tabasco,
+        required this.teleianthous,
+        required this.uncombated,
+    });
+
+    factory Scatty.fromJson(Map<String, dynamic> json) => Scatty(
+        aeriferous: json["aeriferous"],
+        antical: json["antical"],
+        antighostism: json["antighostism"],
+        arcanum: json["arcanum"],
+        autotrophy: json["autotrophy"],
+        baronial: json["baronial"],
+        caffeine: json["caffeine"],
+        gorgoniacean: json["gorgoniacean"],
+        heroical: json["heroical"],
+        hydropical: json["hydropical"],
+        mechanology: json["mechanology"],
+        musicopoetic: json["musicopoetic"],
+        officiality: json["officiality"],
+        oftentimes: json["oftentimes"],
+        ophthalmotonometer: json["ophthalmotonometer"],
+        reflectively: json["reflectively"],
+        springer: json["springer"],
+        tabasco: json["Tabasco"],
+        teleianthous: json["teleianthous"],
+        uncombated: json["uncombated"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "aeriferous": aeriferous,
+        "antical": antical,
+        "antighostism": antighostism,
+        "arcanum": arcanum,
+        "autotrophy": autotrophy,
+        "baronial": baronial,
+        "caffeine": caffeine,
+        "gorgoniacean": gorgoniacean,
+        "heroical": heroical,
+        "hydropical": hydropical,
+        "mechanology": mechanology,
+        "musicopoetic": musicopoetic,
+        "officiality": officiality,
+        "oftentimes": oftentimes,
+        "ophthalmotonometer": ophthalmotonometer,
+        "reflectively": reflectively,
+        "springer": springer,
+        "Tabasco": tabasco,
+        "teleianthous": teleianthous,
+        "uncombated": uncombated,
+    };
+}
+
+class SisteringClass {
+    dynamic amphicarpic;
+    dynamic chianti;
+    dynamic frigorific;
+    dynamic haplomi;
+    dynamic hyperkinesis;
+    dynamic laudable;
+    dynamic madwoman;
+    dynamic maimedly;
+    dynamic micropterygidae;
+    dynamic microrhabdus;
+    dynamic nondense;
+    dynamic phlebemphraxis;
+    dynamic redsear;
+    dynamic schismatical;
+    dynamic tartryl;
+    dynamic unabhorred;
+    dynamic undeliberateness;
+    dynamic unmixable;
+    dynamic untruckling;
+    dynamic vineal;
+
+    SisteringClass({
+        required this.amphicarpic,
+        required this.chianti,
+        required this.frigorific,
+        required this.haplomi,
+        required this.hyperkinesis,
+        required this.laudable,
+        required this.madwoman,
+        required this.maimedly,
+        required this.micropterygidae,
+        required this.microrhabdus,
+        required this.nondense,
+        required this.phlebemphraxis,
+        required this.redsear,
+        required this.schismatical,
+        required this.tartryl,
+        required this.unabhorred,
+        required this.undeliberateness,
+        required this.unmixable,
+        required this.untruckling,
+        required this.vineal,
+    });
+
+    factory SisteringClass.fromJson(Map<String, dynamic> json) => SisteringClass(
+        amphicarpic: json["amphicarpic"],
+        chianti: json["Chianti"],
+        frigorific: json["frigorific"],
+        haplomi: json["Haplomi"],
+        hyperkinesis: json["hyperkinesis"],
+        laudable: json["laudable"],
+        madwoman: json["madwoman"],
+        maimedly: json["maimedly"],
+        micropterygidae: json["Micropterygidae"],
+        microrhabdus: json["microrhabdus"],
+        nondense: json["nondense"],
+        phlebemphraxis: json["phlebemphraxis"],
+        redsear: json["redsear"],
+        schismatical: json["schismatical"],
+        tartryl: json["tartryl"],
+        unabhorred: json["unabhorred"],
+        undeliberateness: json["undeliberateness"],
+        unmixable: json["unmixable"],
+        untruckling: json["untruckling"],
+        vineal: json["vineal"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "amphicarpic": amphicarpic,
+        "Chianti": chianti,
+        "frigorific": frigorific,
+        "Haplomi": haplomi,
+        "hyperkinesis": hyperkinesis,
+        "laudable": laudable,
+        "madwoman": madwoman,
+        "maimedly": maimedly,
+        "Micropterygidae": micropterygidae,
+        "microrhabdus": microrhabdus,
+        "nondense": nondense,
+        "phlebemphraxis": phlebemphraxis,
+        "redsear": redsear,
+        "schismatical": schismatical,
+        "tartryl": tartryl,
+        "unabhorred": unabhorred,
+        "undeliberateness": undeliberateness,
+        "unmixable": unmixable,
+        "untruckling": untruckling,
+        "vineal": vineal,
+    };
+}
+
+class Staghunting {
+    int? calorimetric;
+    int? canid;
+    double? catharticalness;
+    int? chirotherium;
+    String? disdiapason;
+    int? ditriglyphic;
+    int? floriferousness;
+    int? gamelike;
+    int? grig;
+    bool? homocerc;
+    int? interloan;
+    int? lithotomy;
+    int? loric;
+    int? membranocoriaceous;
+    int? membranogenic;
+    dynamic nonbookish;
+    int? overtrump;
+    int? scotino;
+    int? seasonable;
+    int? sephen;
+    int? stigmarioid;
+    int? tired;
+    int? trifid;
+    int? undefeatedly;
+    int? ungirlish;
+
+    Staghunting({
+        this.calorimetric,
+        this.canid,
+        this.catharticalness,
+        this.chirotherium,
+        this.disdiapason,
+        this.ditriglyphic,
+        this.floriferousness,
+        this.gamelike,
+        this.grig,
+        this.homocerc,
+        this.interloan,
+        this.lithotomy,
+        this.loric,
+        this.membranocoriaceous,
+        this.membranogenic,
+        this.nonbookish,
+        this.overtrump,
+        this.scotino,
+        this.seasonable,
+        this.sephen,
+        this.stigmarioid,
+        this.tired,
+        this.trifid,
+        this.undefeatedly,
+        this.ungirlish,
+    });
+
+    factory Staghunting.fromJson(Map<String, dynamic> json) => Staghunting(
+        calorimetric: json["calorimetric"],
+        canid: json["canid"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        disdiapason: json["disdiapason"],
+        ditriglyphic: json["ditriglyphic"],
+        floriferousness: json["floriferousness"],
+        gamelike: json["gamelike"],
+        grig: json["grig"],
+        homocerc: json["homocerc"],
+        interloan: json["interloan"],
+        lithotomy: json["lithotomy"],
+        loric: json["loric"],
+        membranocoriaceous: json["membranocoriaceous"],
+        membranogenic: json["membranogenic"],
+        nonbookish: json["nonbookish"],
+        overtrump: json["overtrump"],
+        scotino: json["scotino"],
+        seasonable: json["seasonable"],
+        sephen: json["sephen"],
+        stigmarioid: json["stigmarioid"],
+        tired: json["tired"],
+        trifid: json["trifid"],
+        undefeatedly: json["undefeatedly"],
+        ungirlish: json["ungirlish"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "calorimetric": calorimetric,
+        "canid": canid,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "disdiapason": disdiapason,
+        "ditriglyphic": ditriglyphic,
+        "floriferousness": floriferousness,
+        "gamelike": gamelike,
+        "grig": grig,
+        "homocerc": homocerc,
+        "interloan": interloan,
+        "lithotomy": lithotomy,
+        "loric": loric,
+        "membranocoriaceous": membranocoriaceous,
+        "membranogenic": membranogenic,
+        "nonbookish": nonbookish,
+        "overtrump": overtrump,
+        "scotino": scotino,
+        "seasonable": seasonable,
+        "sephen": sephen,
+        "stigmarioid": stigmarioid,
+        "tired": tired,
+        "trifid": trifid,
+        "undefeatedly": undefeatedly,
+        "ungirlish": ungirlish,
+    };
+}
+
+class StrenuosityClass {
+    int? bliss;
+    int? buccate;
+    int? bulletproof;
+    double? catharticalness;
+    int? chirotherium;
+    int? crumblingness;
+    String? disdiapason;
+    int? engagedly;
+    int? fightable;
+    int? hoariness;
+    bool? homocerc;
+    int? hypopodium;
+    int? luxurist;
+    int? mechanician;
+    dynamic nonbookish;
+    int? onopordon;
+    int? podgily;
+    int? reformableness;
+    int? scatterbrains;
+    int? seminuria;
+    int? sodomite;
+    int? tramp;
+    int? undueness;
+    int? worthily;
+    int? yankeeist;
+
+    StrenuosityClass({
+        this.bliss,
+        this.buccate,
+        this.bulletproof,
+        this.catharticalness,
+        this.chirotherium,
+        this.crumblingness,
+        this.disdiapason,
+        this.engagedly,
+        this.fightable,
+        this.hoariness,
+        this.homocerc,
+        this.hypopodium,
+        this.luxurist,
+        this.mechanician,
+        this.nonbookish,
+        this.onopordon,
+        this.podgily,
+        this.reformableness,
+        this.scatterbrains,
+        this.seminuria,
+        this.sodomite,
+        this.tramp,
+        this.undueness,
+        this.worthily,
+        this.yankeeist,
+    });
+
+    factory StrenuosityClass.fromJson(Map<String, dynamic> json) => StrenuosityClass(
+        bliss: json["bliss"],
+        buccate: json["buccate"],
+        bulletproof: json["bulletproof"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        crumblingness: json["crumblingness"],
+        disdiapason: json["disdiapason"],
+        engagedly: json["engagedly"],
+        fightable: json["fightable"],
+        hoariness: json["hoariness"],
+        homocerc: json["homocerc"],
+        hypopodium: json["hypopodium"],
+        luxurist: json["luxurist"],
+        mechanician: json["mechanician"],
+        nonbookish: json["nonbookish"],
+        onopordon: json["Onopordon"],
+        podgily: json["podgily"],
+        reformableness: json["reformableness"],
+        scatterbrains: json["scatterbrains"],
+        seminuria: json["seminuria"],
+        sodomite: json["Sodomite"],
+        tramp: json["tramp"],
+        undueness: json["undueness"],
+        worthily: json["worthily"],
+        yankeeist: json["Yankeeist"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "bliss": bliss,
+        "buccate": buccate,
+        "bulletproof": bulletproof,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "crumblingness": crumblingness,
+        "disdiapason": disdiapason,
+        "engagedly": engagedly,
+        "fightable": fightable,
+        "hoariness": hoariness,
+        "homocerc": homocerc,
+        "hypopodium": hypopodium,
+        "luxurist": luxurist,
+        "mechanician": mechanician,
+        "nonbookish": nonbookish,
+        "Onopordon": onopordon,
+        "podgily": podgily,
+        "reformableness": reformableness,
+        "scatterbrains": scatterbrains,
+        "seminuria": seminuria,
+        "Sodomite": sodomite,
+        "tramp": tramp,
+        "undueness": undueness,
+        "worthily": worthily,
+        "Yankeeist": yankeeist,
+    };
+}
+
+class TruantcyClass {
+    dynamic alfiona;
+    dynamic ascaridiasis;
+    dynamic bungey;
+    double? catharticalness;
+    dynamic ceroxyle;
+    int? chirotherium;
+    dynamic chorology;
+    String? disdiapason;
+    dynamic enmarble;
+    dynamic epeira;
+    dynamic eurylaimi;
+    dynamic germination;
+    dynamic hallelujah;
+    bool? homocerc;
+    dynamic lev;
+    dynamic mouthing;
+    dynamic nonbookish;
+    dynamic philliloo;
+    dynamic planetal;
+    dynamic poney;
+    dynamic punctualist;
+    dynamic returnlessly;
+    dynamic skelder;
+    dynamic windwaywardly;
+    dynamic yuman;
+
+    TruantcyClass({
+        this.alfiona,
+        this.ascaridiasis,
+        this.bungey,
+        this.catharticalness,
+        this.ceroxyle,
+        this.chirotherium,
+        this.chorology,
+        this.disdiapason,
+        this.enmarble,
+        this.epeira,
+        this.eurylaimi,
+        this.germination,
+        this.hallelujah,
+        this.homocerc,
+        this.lev,
+        this.mouthing,
+        this.nonbookish,
+        this.philliloo,
+        this.planetal,
+        this.poney,
+        this.punctualist,
+        this.returnlessly,
+        this.skelder,
+        this.windwaywardly,
+        this.yuman,
+    });
+
+    factory TruantcyClass.fromJson(Map<String, dynamic> json) => TruantcyClass(
+        alfiona: json["alfiona"],
+        ascaridiasis: json["ascaridiasis"],
+        bungey: json["bungey"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        ceroxyle: json["ceroxyle"],
+        chirotherium: json["Chirotherium"],
+        chorology: json["chorology"],
+        disdiapason: json["disdiapason"],
+        enmarble: json["enmarble"],
+        epeira: json["Epeira"],
+        eurylaimi: json["Eurylaimi"],
+        germination: json["germination"],
+        hallelujah: json["hallelujah"],
+        homocerc: json["homocerc"],
+        lev: json["lev"],
+        mouthing: json["mouthing"],
+        nonbookish: json["nonbookish"],
+        philliloo: json["philliloo"],
+        planetal: json["planetal"],
+        poney: json["poney"],
+        punctualist: json["punctualist"],
+        returnlessly: json["returnlessly"],
+        skelder: json["skelder"],
+        windwaywardly: json["windwaywardly"],
+        yuman: json["Yuman"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "alfiona": alfiona,
+        "ascaridiasis": ascaridiasis,
+        "bungey": bungey,
+        "catharticalness": catharticalness,
+        "ceroxyle": ceroxyle,
+        "Chirotherium": chirotherium,
+        "chorology": chorology,
+        "disdiapason": disdiapason,
+        "enmarble": enmarble,
+        "Epeira": epeira,
+        "Eurylaimi": eurylaimi,
+        "germination": germination,
+        "hallelujah": hallelujah,
+        "homocerc": homocerc,
+        "lev": lev,
+        "mouthing": mouthing,
+        "nonbookish": nonbookish,
+        "philliloo": philliloo,
+        "planetal": planetal,
+        "poney": poney,
+        "punctualist": punctualist,
+        "returnlessly": returnlessly,
+        "skelder": skelder,
+        "windwaywardly": windwaywardly,
+        "Yuman": yuman,
+    };
+}
+
+class UnimpeachablyClass {
+    int? acerin;
+    int? bobadil;
+    double? catharticalness;
+    int? chirotherium;
+    int? chlorophylligenous;
+    int? conversational;
+    int? demiowl;
+    String? disdiapason;
+    int? ectorhinal;
+    int? gamblesomeness;
+    bool? homocerc;
+    int? irrorate;
+    int? kindergartening;
+    int? lateritic;
+    int? mespil;
+    int? misconfiguration;
+    dynamic nonbookish;
+    int? planometry;
+    int? quiina;
+    int? robert;
+    int? rot;
+    int? subcinctorium;
+    int? tussocker;
+    int? ultraproud;
+    int? unsuggestedness;
+
+    UnimpeachablyClass({
+        this.acerin,
+        this.bobadil,
+        this.catharticalness,
+        this.chirotherium,
+        this.chlorophylligenous,
+        this.conversational,
+        this.demiowl,
+        this.disdiapason,
+        this.ectorhinal,
+        this.gamblesomeness,
+        this.homocerc,
+        this.irrorate,
+        this.kindergartening,
+        this.lateritic,
+        this.mespil,
+        this.misconfiguration,
+        this.nonbookish,
+        this.planometry,
+        this.quiina,
+        this.robert,
+        this.rot,
+        this.subcinctorium,
+        this.tussocker,
+        this.ultraproud,
+        this.unsuggestedness,
+    });
+
+    factory UnimpeachablyClass.fromJson(Map<String, dynamic> json) => UnimpeachablyClass(
+        acerin: json["acerin"],
+        bobadil: json["Bobadil"],
+        catharticalness: json["catharticalness"]?.toDouble(),
+        chirotherium: json["Chirotherium"],
+        chlorophylligenous: json["chlorophylligenous"],
+        conversational: json["conversational"],
+        demiowl: json["demiowl"],
+        disdiapason: json["disdiapason"],
+        ectorhinal: json["ectorhinal"],
+        gamblesomeness: json["gamblesomeness"],
+        homocerc: json["homocerc"],
+        irrorate: json["irrorate"],
+        kindergartening: json["kindergartening"],
+        lateritic: json["lateritic"],
+        mespil: json["mespil"],
+        misconfiguration: json["misconfiguration"],
+        nonbookish: json["nonbookish"],
+        planometry: json["planometry"],
+        quiina: json["Quiina"],
+        robert: json["Robert"],
+        rot: json["rot"],
+        subcinctorium: json["subcinctorium"],
+        tussocker: json["tussocker"],
+        ultraproud: json["ultraproud"],
+        unsuggestedness: json["unsuggestedness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "acerin": acerin,
+        "Bobadil": bobadil,
+        "catharticalness": catharticalness,
+        "Chirotherium": chirotherium,
+        "chlorophylligenous": chlorophylligenous,
+        "conversational": conversational,
+        "demiowl": demiowl,
+        "disdiapason": disdiapason,
+        "ectorhinal": ectorhinal,
+        "gamblesomeness": gamblesomeness,
+        "homocerc": homocerc,
+        "irrorate": irrorate,
+        "kindergartening": kindergartening,
+        "lateritic": lateritic,
+        "mespil": mespil,
+        "misconfiguration": misconfiguration,
+        "nonbookish": nonbookish,
+        "planometry": planometry,
+        "Quiina": quiina,
+        "Robert": robert,
+        "rot": rot,
+        "subcinctorium": subcinctorium,
+        "tussocker": tussocker,
+        "ultraproud": ultraproud,
+        "unsuggestedness": unsuggestedness,
+    };
+}
+
+class UnstressedClass {
+    dynamic alain;
+    dynamic amphirhina;
+    dynamic antimachinery;
+    dynamic coldish;
+    dynamic crantara;
+    dynamic distinguishing;
+    dynamic elytroposis;
+    dynamic gentianwort;
+    dynamic heliosis;
+    dynamic instrumental;
+    dynamic introinflection;
+    dynamic kala;
+    dynamic lincolnian;
+    dynamic metad;
+    dynamic sarcophilus;
+    dynamic swingingly;
+    dynamic unconformity;
+    dynamic undecreed;
+    dynamic venerable;
+    dynamic vowellessness;
+
+    UnstressedClass({
+        required this.alain,
+        required this.amphirhina,
+        required this.antimachinery,
+        required this.coldish,
+        required this.crantara,
+        required this.distinguishing,
+        required this.elytroposis,
+        required this.gentianwort,
+        required this.heliosis,
+        required this.instrumental,
+        required this.introinflection,
+        required this.kala,
+        required this.lincolnian,
+        required this.metad,
+        required this.sarcophilus,
+        required this.swingingly,
+        required this.unconformity,
+        required this.undecreed,
+        required this.venerable,
+        required this.vowellessness,
+    });
+
+    factory UnstressedClass.fromJson(Map<String, dynamic> json) => UnstressedClass(
+        alain: json["Alain"],
+        amphirhina: json["Amphirhina"],
+        antimachinery: json["antimachinery"],
+        coldish: json["coldish"],
+        crantara: json["crantara"],
+        distinguishing: json["distinguishing"],
+        elytroposis: json["elytroposis"],
+        gentianwort: json["gentianwort"],
+        heliosis: json["heliosis"],
+        instrumental: json["instrumental"],
+        introinflection: json["introinflection"],
+        kala: json["kala"],
+        lincolnian: json["Lincolnian"],
+        metad: json["metad"],
+        sarcophilus: json["Sarcophilus"],
+        swingingly: json["swingingly"],
+        unconformity: json["unconformity"],
+        undecreed: json["undecreed"],
+        venerable: json["venerable"],
+        vowellessness: json["vowellessness"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Alain": alain,
+        "Amphirhina": amphirhina,
+        "antimachinery": antimachinery,
+        "coldish": coldish,
+        "crantara": crantara,
+        "distinguishing": distinguishing,
+        "elytroposis": elytroposis,
+        "gentianwort": gentianwort,
+        "heliosis": heliosis,
+        "instrumental": instrumental,
+        "introinflection": introinflection,
+        "kala": kala,
+        "Lincolnian": lincolnian,
+        "metad": metad,
+        "Sarcophilus": sarcophilus,
+        "swingingly": swingingly,
+        "unconformity": unconformity,
+        "undecreed": undecreed,
+        "venerable": venerable,
+        "vowellessness": vowellessness,
+    };
+}
+
+class WrothyClass {
+    dynamic aeschynanthus;
+    dynamic aquiferous;
+    dynamic cheapener;
+    dynamic enumeration;
+    dynamic ephesine;
+    dynamic escadrille;
+    dynamic estrous;
+    dynamic interestedly;
+    dynamic katakinetomer;
+    dynamic mortification;
+    dynamic morula;
+    dynamic orthosymmetrical;
+    dynamic overbark;
+    dynamic politist;
+    dynamic qualified;
+    dynamic sphenomalar;
+    dynamic throatful;
+    dynamic transhumance;
+    dynamic triandrian;
+    dynamic unbooked;
+
+    WrothyClass({
+        required this.aeschynanthus,
+        required this.aquiferous,
+        required this.cheapener,
+        required this.enumeration,
+        required this.ephesine,
+        required this.escadrille,
+        required this.estrous,
+        required this.interestedly,
+        required this.katakinetomer,
+        required this.mortification,
+        required this.morula,
+        required this.orthosymmetrical,
+        required this.overbark,
+        required this.politist,
+        required this.qualified,
+        required this.sphenomalar,
+        required this.throatful,
+        required this.transhumance,
+        required this.triandrian,
+        required this.unbooked,
+    });
+
+    factory WrothyClass.fromJson(Map<String, dynamic> json) => WrothyClass(
+        aeschynanthus: json["Aeschynanthus"],
+        aquiferous: json["aquiferous"],
+        cheapener: json["cheapener"],
+        enumeration: json["enumeration"],
+        ephesine: json["Ephesine"],
+        escadrille: json["escadrille"],
+        estrous: json["estrous"],
+        interestedly: json["interestedly"],
+        katakinetomer: json["katakinetomer"],
+        mortification: json["mortification"],
+        morula: json["morula"],
+        orthosymmetrical: json["orthosymmetrical"],
+        overbark: json["overbark"],
+        politist: json["politist"],
+        qualified: json["qualified"],
+        sphenomalar: json["sphenomalar"],
+        throatful: json["throatful"],
+        transhumance: json["transhumance"],
+        triandrian: json["triandrian"],
+        unbooked: json["unbooked"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "Aeschynanthus": aeschynanthus,
+        "aquiferous": aquiferous,
+        "cheapener": cheapener,
+        "enumeration": enumeration,
+        "Ephesine": ephesine,
+        "escadrille": escadrille,
+        "estrous": estrous,
+        "interestedly": interestedly,
+        "katakinetomer": katakinetomer,
+        "mortification": mortification,
+        "morula": morula,
+        "orthosymmetrical": orthosymmetrical,
+        "overbark": overbark,
+        "politist": politist,
+        "qualified": qualified,
+        "sphenomalar": sphenomalar,
+        "throatful": throatful,
+        "transhumance": transhumance,
+        "triandrian": triandrian,
+        "unbooked": unbooked,
+    };
+}
diff --git a/head/dart/test/inputs/json/priority/direct-recursive.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/direct-recursive.json/default/TopLevel.dart
new file mode 100644
index 0000000..027d880
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/direct-recursive.json/default/TopLevel.dart
@@ -0,0 +1,41 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final TopLevel? also;
+    final bool bar;
+    final int foo;
+    final double moo;
+    final String quux;
+
+    TopLevel({
+        this.also,
+        required this.bar,
+        required this.foo,
+        required this.moo,
+        required this.quux,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        also: json["also"] == null ? null : TopLevel.fromJson(json["also"]),
+        bar: json["bar"],
+        foo: json["foo"],
+        moo: json["moo"]?.toDouble(),
+        quux: json["quux"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "also": also?.toJson(),
+        "bar": bar,
+        "foo": foo,
+        "moo": moo,
+        "quux": quux,
+    };
+}
diff --git a/head/dart/test/inputs/json/priority/list.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/list.json/default/TopLevel.dart
new file mode 100644
index 0000000..12bef77
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/list.json/default/TopLevel.dart
@@ -0,0 +1,29 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final int data;
+    final TopLevel? next;
+
+    TopLevel({
+        required this.data,
+        required this.next,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        data: json["data"],
+        next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "data": data,
+        "next": next?.toJson(),
+    };
+}
diff --git a/head/dart/test/inputs/json/priority/nbl-stats.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/nbl-stats.json/default/TopLevel.dart
new file mode 100644
index 0000000..abf6fd4
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/nbl-stats.json/default/TopLevel.dart
@@ -0,0 +1,1225 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final int attendance;
+    final String clock;
+    final int disableMatch;
+    final int inOt;
+    final List<List<dynamic>> leaddata;
+    final String officialsReferee1;
+    final String officialsReferee2;
+    final String officialsReferee3;
+    final List<Othermatch> othermatches;
+    final List<Pbp> pbp;
+    final int period;
+    final int periodLengthOvertime;
+    final int periodLengthRegular;
+    final PerType periodType;
+    final int periodsMax;
+    final Map<String, List<Scorer>> scorers;
+    final List<dynamic> timeline;
+    final Map<String, Tm> tm;
+    final int totalTimeAdded;
+    final Totallds totallds;
+
+    TopLevel({
+        required this.attendance,
+        required this.clock,
+        required this.disableMatch,
+        required this.inOt,
+        required this.leaddata,
+        required this.officialsReferee1,
+        required this.officialsReferee2,
+        required this.officialsReferee3,
+        required this.othermatches,
+        required this.pbp,
+        required this.period,
+        required this.periodLengthOvertime,
+        required this.periodLengthRegular,
+        required this.periodType,
+        required this.periodsMax,
+        required this.scorers,
+        required this.timeline,
+        required this.tm,
+        required this.totalTimeAdded,
+        required this.totallds,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        attendance: json["attendance"],
+        clock: json["clock"],
+        disableMatch: json["disableMatch"],
+        inOt: json["inOT"],
+        leaddata: List<List<dynamic>>.from(json["leaddata"].map((x) => List<dynamic>.from(x.map((x) => x)))),
+        officialsReferee1: json["officials_referee1"],
+        officialsReferee2: json["officials_referee2"],
+        officialsReferee3: json["officials_referee3"],
+        othermatches: List<Othermatch>.from(json["othermatches"].map((x) => Othermatch.fromJson(x))),
+        pbp: List<Pbp>.from(json["pbp"].map((x) => Pbp.fromJson(x))),
+        period: json["period"],
+        periodLengthOvertime: json["periodLengthOVERTIME"],
+        periodLengthRegular: json["periodLengthREGULAR"],
+        periodType: perTypeValues.map[json["periodType"]]!,
+        periodsMax: json["periodsMax"],
+        scorers: Map.from(json["scorers"]).map((k, v) => MapEntry<String, List<Scorer>>(k, List<Scorer>.from(v.map((x) => Scorer.fromJson(x))))),
+        timeline: List<dynamic>.from(json["timeline"].map((x) => x)),
+        tm: Map.from(json["tm"]).map((k, v) => MapEntry<String, Tm>(k, Tm.fromJson(v))),
+        totalTimeAdded: json["totalTimeAdded"],
+        totallds: Totallds.fromJson(json["totallds"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "attendance": attendance,
+        "clock": clock,
+        "disableMatch": disableMatch,
+        "inOT": inOt,
+        "leaddata": List<dynamic>.from(leaddata.map((x) => List<dynamic>.from(x.map((x) => x)))),
+        "officials_referee1": officialsReferee1,
+        "officials_referee2": officialsReferee2,
+        "officials_referee3": officialsReferee3,
+        "othermatches": List<dynamic>.from(othermatches.map((x) => x.toJson())),
+        "pbp": List<dynamic>.from(pbp.map((x) => x.toJson())),
+        "period": period,
+        "periodLengthOVERTIME": periodLengthOvertime,
+        "periodLengthREGULAR": periodLengthRegular,
+        "periodType": perTypeValues.reverse[periodType],
+        "periodsMax": periodsMax,
+        "scorers": Map.from(scorers).map((k, v) => MapEntry<String, dynamic>(k, List<dynamic>.from(v.map((x) => x.toJson())))),
+        "timeline": List<dynamic>.from(timeline.map((x) => x)),
+        "tm": Map.from(tm).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "totalTimeAdded": totalTimeAdded,
+        "totallds": totallds.toJson(),
+    };
+}
+
+enum LeaddatumEnum {
+    EMPTY,
+    P1,
+    P2,
+    P3,
+    P4
+}
+
+final leaddatumEnumValues = EnumValues({
+    "": LeaddatumEnum.EMPTY,
+    "P1": LeaddatumEnum.P1,
+    "P2": LeaddatumEnum.P2,
+    "P3": LeaddatumEnum.P3,
+    "P4": LeaddatumEnum.P4
+});
+
+class Othermatch {
+    final String clock;
+    final String competitionName;
+    final String id;
+    final int period;
+    final PerType periodType;
+    final Team team1;
+    final String team1Name;
+    final int team1Score;
+    final Team team2;
+    final String team2Name;
+    final int team2Score;
+
+    Othermatch({
+        required this.clock,
+        required this.competitionName,
+        required this.id,
+        required this.period,
+        required this.periodType,
+        required this.team1,
+        required this.team1Name,
+        required this.team1Score,
+        required this.team2,
+        required this.team2Name,
+        required this.team2Score,
+    });
+
+    factory Othermatch.fromJson(Map<String, dynamic> json) => Othermatch(
+        clock: json["clock"],
+        competitionName: json["competitionName"],
+        id: json["id"],
+        period: json["period"],
+        periodType: perTypeValues.map[json["periodType"]]!,
+        team1: Team.fromJson(json["team1"]),
+        team1Name: json["team1Name"],
+        team1Score: json["team1Score"],
+        team2: Team.fromJson(json["team2"]),
+        team2Name: json["team2Name"],
+        team2Score: json["team2Score"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "clock": clock,
+        "competitionName": competitionName,
+        "id": id,
+        "period": period,
+        "periodType": perTypeValues.reverse[periodType],
+        "team1": team1.toJson(),
+        "team1Name": team1Name,
+        "team1Score": team1Score,
+        "team2": team2.toJson(),
+        "team2Name": team2Name,
+        "team2Score": team2Score,
+    };
+}
+
+enum PerType {
+    REGULAR
+}
+
+final perTypeValues = EnumValues({
+    "REGULAR": PerType.REGULAR
+});
+
+class Team {
+    final String teamCode;
+    final String teamCodeInternational;
+    final String teamName;
+    final String teamNameInternational;
+
+    Team({
+        required this.teamCode,
+        required this.teamCodeInternational,
+        required this.teamName,
+        required this.teamNameInternational,
+    });
+
+    factory Team.fromJson(Map<String, dynamic> json) => Team(
+        teamCode: json["teamCode"],
+        teamCodeInternational: json["teamCodeInternational"],
+        teamName: json["teamName"],
+        teamNameInternational: json["teamNameInternational"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "teamCode": teamCode,
+        "teamCodeInternational": teamCodeInternational,
+        "teamName": teamName,
+        "teamNameInternational": teamNameInternational,
+    };
+}
+
+class Pbp {
+    final ActionType actionType;
+    final String? familyName;
+    final FamilyNameInitial? familyNameInitial;
+    final String? firstName;
+    final FirstNameInitial? firstNameInitial;
+    final String gt;
+    final String? internationalFamilyName;
+    final FamilyNameInitial? internationalFamilyNameInitial;
+    final String? internationalFirstName;
+    final FirstNameInitial? internationalFirstNameInitial;
+    final int lead;
+    final int period;
+    final PerType periodType;
+    final String player;
+    final int pno;
+    final String qualifier;
+    final int s1;
+    final int s2;
+    final ScoreboardName? scoreboardName;
+    final int scoring;
+    final String shirtNumber;
+    final String subType;
+    final int success;
+    final int tno;
+
+    Pbp({
+        required this.actionType,
+        this.familyName,
+        this.familyNameInitial,
+        this.firstName,
+        this.firstNameInitial,
+        required this.gt,
+        this.internationalFamilyName,
+        this.internationalFamilyNameInitial,
+        this.internationalFirstName,
+        this.internationalFirstNameInitial,
+        required this.lead,
+        required this.period,
+        required this.periodType,
+        required this.player,
+        required this.pno,
+        required this.qualifier,
+        required this.s1,
+        required this.s2,
+        this.scoreboardName,
+        required this.scoring,
+        required this.shirtNumber,
+        required this.subType,
+        required this.success,
+        required this.tno,
+    });
+
+    factory Pbp.fromJson(Map<String, dynamic> json) => Pbp(
+        actionType: actionTypeValues.map[json["actionType"]]!,
+        familyName: json["familyName"],
+        familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]],
+        firstName: json["firstName"],
+        firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]],
+        gt: json["gt"],
+        internationalFamilyName: json["internationalFamilyName"],
+        internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]],
+        internationalFirstName: json["internationalFirstName"],
+        internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]],
+        lead: json["lead"],
+        period: json["period"],
+        periodType: perTypeValues.map[json["periodType"]]!,
+        player: json["player"],
+        pno: json["pno"],
+        qualifier: json["qualifier"],
+        s1: json["s1"],
+        s2: json["s2"],
+        scoreboardName: scoreboardNameValues.map[json["scoreboardName"]],
+        scoring: json["scoring"],
+        shirtNumber: json["shirtNumber"],
+        subType: json["subType"],
+        success: json["success"],
+        tno: json["tno"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "actionType": actionTypeValues.reverse[actionType],
+        "familyName": familyName,
+        "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial],
+        "firstName": firstName,
+        "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial],
+        "gt": gt,
+        "internationalFamilyName": internationalFamilyName,
+        "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial],
+        "internationalFirstName": internationalFirstName,
+        "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial],
+        "lead": lead,
+        "period": period,
+        "periodType": perTypeValues.reverse[periodType],
+        "player": player,
+        "pno": pno,
+        "qualifier": qualifier,
+        "s1": s1,
+        "s2": s2,
+        "scoreboardName": scoreboardNameValues.reverse[scoreboardName],
+        "scoring": scoring,
+        "shirtNumber": shirtNumber,
+        "subType": subType,
+        "success": success,
+        "tno": tno,
+    };
+}
+
+enum ActionType {
+    GAME,
+    PERIOD,
+    THE_3_PT,
+    THE_2_PT,
+    REBOUND,
+    TIMEOUT,
+    FOULON,
+    FOUL,
+    ASSIST,
+    SUBSTITUTION,
+    FREETHROW,
+    STEAL,
+    TURNOVER,
+    BLOCK,
+    JUMPBALL
+}
+
+final actionTypeValues = EnumValues({
+    "game": ActionType.GAME,
+    "period": ActionType.PERIOD,
+    "3pt": ActionType.THE_3_PT,
+    "2pt": ActionType.THE_2_PT,
+    "rebound": ActionType.REBOUND,
+    "timeout": ActionType.TIMEOUT,
+    "foulon": ActionType.FOULON,
+    "foul": ActionType.FOUL,
+    "assist": ActionType.ASSIST,
+    "substitution": ActionType.SUBSTITUTION,
+    "freethrow": ActionType.FREETHROW,
+    "steal": ActionType.STEAL,
+    "turnover": ActionType.TURNOVER,
+    "block": ActionType.BLOCK,
+    "jumpball": ActionType.JUMPBALL
+});
+
+enum FamilyNameInitial {
+    R,
+    M,
+    S,
+    C,
+    O,
+    W,
+    A,
+    P,
+    V,
+    I,
+    J,
+    FAMILY_NAME_INITIAL_S,
+    H,
+    B
+}
+
+final familyNameInitialValues = EnumValues({
+    "R": FamilyNameInitial.R,
+    "M": FamilyNameInitial.M,
+    "s": FamilyNameInitial.S,
+    "C": FamilyNameInitial.C,
+    "O": FamilyNameInitial.O,
+    "W": FamilyNameInitial.W,
+    "A": FamilyNameInitial.A,
+    "P": FamilyNameInitial.P,
+    "V": FamilyNameInitial.V,
+    "I": FamilyNameInitial.I,
+    "J": FamilyNameInitial.J,
+    "S": FamilyNameInitial.FAMILY_NAME_INITIAL_S,
+    "H": FamilyNameInitial.H,
+    "B": FamilyNameInitial.B
+});
+
+enum FirstNameInitial {
+    D,
+    J,
+    T,
+    C,
+    O,
+    H,
+    L,
+    A,
+    K,
+    R,
+    B,
+    N
+}
+
+final firstNameInitialValues = EnumValues({
+    "D": FirstNameInitial.D,
+    "J": FirstNameInitial.J,
+    "T": FirstNameInitial.T,
+    "C": FirstNameInitial.C,
+    "O": FirstNameInitial.O,
+    "H": FirstNameInitial.H,
+    "L": FirstNameInitial.L,
+    "A": FirstNameInitial.A,
+    "K": FirstNameInitial.K,
+    "R": FirstNameInitial.R,
+    "B": FirstNameInitial.B,
+    "N": FirstNameInitial.N
+});
+
+enum ScoreboardName {
+    EMPTY,
+    T_S,
+    R_IHATA,
+    D_JONES,
+    B_VALENTINE
+}
+
+final scoreboardNameValues = EnumValues({
+    "": ScoreboardName.EMPTY,
+    "T. s": ScoreboardName.T_S,
+    "R. Ihata": ScoreboardName.R_IHATA,
+    "D. Jones": ScoreboardName.D_JONES,
+    "B. Valentine": ScoreboardName.B_VALENTINE
+});
+
+class Scorer {
+    final String? familyName;
+    final FamilyNameInitial? familyNameInitial;
+    final String? firstName;
+    final FirstNameInitial? firstNameInitial;
+    final String? gt;
+    final String? internationalFamilyName;
+    final FamilyNameInitial? internationalFamilyNameInitial;
+    final String? internationalFirstName;
+    final FirstNameInitial? internationalFirstNameInitial;
+    final String? name;
+    final int? per;
+    final PerType? perType;
+    final String? player;
+    final int pno;
+    final ScoreboardName? scoreboardName;
+    final String shirtNumber;
+    final String? summary;
+    final List<Time>? times;
+    final int tno;
+    final int? tot;
+
+    Scorer({
+        this.familyName,
+        this.familyNameInitial,
+        this.firstName,
+        this.firstNameInitial,
+        this.gt,
+        this.internationalFamilyName,
+        this.internationalFamilyNameInitial,
+        this.internationalFirstName,
+        this.internationalFirstNameInitial,
+        this.name,
+        this.per,
+        this.perType,
+        this.player,
+        required this.pno,
+        this.scoreboardName,
+        required this.shirtNumber,
+        this.summary,
+        this.times,
+        required this.tno,
+        this.tot,
+    });
+
+    factory Scorer.fromJson(Map<String, dynamic> json) => Scorer(
+        familyName: json["familyName"],
+        familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]],
+        firstName: json["firstName"],
+        firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]],
+        gt: json["gt"],
+        internationalFamilyName: json["internationalFamilyName"],
+        internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]],
+        internationalFirstName: json["internationalFirstName"],
+        internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]],
+        name: json["name"],
+        per: json["per"],
+        perType: perTypeValues.map[json["perType"]],
+        player: json["player"],
+        pno: json["pno"],
+        scoreboardName: scoreboardNameValues.map[json["scoreboardName"]],
+        shirtNumber: json["shirtNumber"],
+        summary: json["summary"],
+        times: json["times"] == null ? null : List<Time>.from(json["times"]!.map((x) => Time.fromJson(x))),
+        tno: json["tno"],
+        tot: json["tot"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "familyName": familyName,
+        "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial],
+        "firstName": firstName,
+        "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial],
+        "gt": gt,
+        "internationalFamilyName": internationalFamilyName,
+        "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial],
+        "internationalFirstName": internationalFirstName,
+        "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial],
+        "name": name,
+        "per": per,
+        "perType": perTypeValues.reverse[perType],
+        "player": player,
+        "pno": pno,
+        "scoreboardName": scoreboardNameValues.reverse[scoreboardName],
+        "shirtNumber": shirtNumber,
+        "summary": summary,
+        "times": times == null ? null : List<dynamic>.from(times!.map((x) => x.toJson())),
+        "tno": tno,
+        "tot": tot,
+    };
+}
+
+class Time {
+    final String gt;
+    final int per;
+    final PerType perType;
+
+    Time({
+        required this.gt,
+        required this.per,
+        required this.perType,
+    });
+
+    factory Time.fromJson(Map<String, dynamic> json) => Time(
+        gt: json["gt"],
+        per: json["per"],
+        perType: perTypeValues.map[json["perType"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "gt": gt,
+        "per": per,
+        "perType": perTypeValues.reverse[perType],
+    };
+}
+
+class Tm {
+    final String code;
+    final String codeInternational;
+    final int fouls;
+    final int fullScore;
+    final Lds lds;
+    final String logo;
+    final String name;
+    final String nameInternational;
+    final int p1Score;
+    final int p2Score;
+    final int p3Score;
+    final int p4Score;
+    final Map<String, Pl> pl;
+    final int score;
+    final List<Scorer> scoring;
+    final String shortName;
+    final String shortNameInternational;
+    final List<Shot> shot;
+    final int timeouts;
+    final int totEff1;
+    final int totEff2;
+    final double totEff3;
+    final int totEff4;
+    final int totEff5;
+    final int totEff6;
+    final int totEff7;
+    final int totSAssists;
+    final int totSBenchPoints;
+    final int totSBiggestLead;
+    final int totSBiggestScoringRun;
+    final int totSBlocks;
+    final int totSBlocksReceived;
+    final int totSFieldGoalsAttempted;
+    final int totSFieldGoalsMade;
+    final int totSFieldGoalsPercentage;
+    final int totSFoulsOn;
+    final int totSFoulsPersonal;
+    final int totSFoulsTeam;
+    final int totSFreeThrowsAttempted;
+    final int totSFreeThrowsMade;
+    final int totSFreeThrowsPercentage;
+    final int totSLeadChanges;
+    final int totSMinutes;
+    final int totSPoints;
+    final int totSPointsFastBreak;
+    final int totSPointsFromTurnovers;
+    final int totSPointsInThePaint;
+    final int totSPointsSecondChance;
+    final int totSReboundsDefensive;
+    final int totSReboundsOffensive;
+    final int totSReboundsTeam;
+    final int totSReboundsTeamDefensive;
+    final int totSReboundsTeamOffensive;
+    final int totSReboundsTotal;
+    final int totSSteals;
+    final int totSThreePointersAttempted;
+    final int totSThreePointersMade;
+    final int totSThreePointersPercentage;
+    final double totSTimeLeading;
+    final int totSTimesScoresLevel;
+    final int totSTurnovers;
+    final int totSTurnoversTeam;
+    final int totSTwoPointersAttempted;
+    final int totSTwoPointersMade;
+    final int totSTwoPointersPercentage;
+
+    Tm({
+        required this.code,
+        required this.codeInternational,
+        required this.fouls,
+        required this.fullScore,
+        required this.lds,
+        required this.logo,
+        required this.name,
+        required this.nameInternational,
+        required this.p1Score,
+        required this.p2Score,
+        required this.p3Score,
+        required this.p4Score,
+        required this.pl,
+        required this.score,
+        required this.scoring,
+        required this.shortName,
+        required this.shortNameInternational,
+        required this.shot,
+        required this.timeouts,
+        required this.totEff1,
+        required this.totEff2,
+        required this.totEff3,
+        required this.totEff4,
+        required this.totEff5,
+        required this.totEff6,
+        required this.totEff7,
+        required this.totSAssists,
+        required this.totSBenchPoints,
+        required this.totSBiggestLead,
+        required this.totSBiggestScoringRun,
+        required this.totSBlocks,
+        required this.totSBlocksReceived,
+        required this.totSFieldGoalsAttempted,
+        required this.totSFieldGoalsMade,
+        required this.totSFieldGoalsPercentage,
+        required this.totSFoulsOn,
+        required this.totSFoulsPersonal,
+        required this.totSFoulsTeam,
+        required this.totSFreeThrowsAttempted,
+        required this.totSFreeThrowsMade,
+        required this.totSFreeThrowsPercentage,
+        required this.totSLeadChanges,
+        required this.totSMinutes,
+        required this.totSPoints,
+        required this.totSPointsFastBreak,
+        required this.totSPointsFromTurnovers,
+        required this.totSPointsInThePaint,
+        required this.totSPointsSecondChance,
+        required this.totSReboundsDefensive,
+        required this.totSReboundsOffensive,
+        required this.totSReboundsTeam,
+        required this.totSReboundsTeamDefensive,
+        required this.totSReboundsTeamOffensive,
+        required this.totSReboundsTotal,
+        required this.totSSteals,
+        required this.totSThreePointersAttempted,
+        required this.totSThreePointersMade,
+        required this.totSThreePointersPercentage,
+        required this.totSTimeLeading,
+        required this.totSTimesScoresLevel,
+        required this.totSTurnovers,
+        required this.totSTurnoversTeam,
+        required this.totSTwoPointersAttempted,
+        required this.totSTwoPointersMade,
+        required this.totSTwoPointersPercentage,
+    });
+
+    factory Tm.fromJson(Map<String, dynamic> json) => Tm(
+        code: json["code"],
+        codeInternational: json["codeInternational"],
+        fouls: json["fouls"],
+        fullScore: json["full_score"],
+        lds: Lds.fromJson(json["lds"]),
+        logo: json["logo"],
+        name: json["name"],
+        nameInternational: json["nameInternational"],
+        p1Score: json["p1_score"],
+        p2Score: json["p2_score"],
+        p3Score: json["p3_score"],
+        p4Score: json["p4_score"],
+        pl: Map.from(json["pl"]).map((k, v) => MapEntry<String, Pl>(k, Pl.fromJson(v))),
+        score: json["score"],
+        scoring: List<Scorer>.from(json["scoring"].map((x) => Scorer.fromJson(x))),
+        shortName: json["shortName"],
+        shortNameInternational: json["shortNameInternational"],
+        shot: List<Shot>.from(json["shot"].map((x) => Shot.fromJson(x))),
+        timeouts: json["timeouts"],
+        totEff1: json["tot_eff_1"],
+        totEff2: json["tot_eff_2"],
+        totEff3: json["tot_eff_3"]?.toDouble(),
+        totEff4: json["tot_eff_4"],
+        totEff5: json["tot_eff_5"],
+        totEff6: json["tot_eff_6"],
+        totEff7: json["tot_eff_7"],
+        totSAssists: json["tot_sAssists"],
+        totSBenchPoints: json["tot_sBenchPoints"],
+        totSBiggestLead: json["tot_sBiggestLead"],
+        totSBiggestScoringRun: json["tot_sBiggestScoringRun"],
+        totSBlocks: json["tot_sBlocks"],
+        totSBlocksReceived: json["tot_sBlocksReceived"],
+        totSFieldGoalsAttempted: json["tot_sFieldGoalsAttempted"],
+        totSFieldGoalsMade: json["tot_sFieldGoalsMade"],
+        totSFieldGoalsPercentage: json["tot_sFieldGoalsPercentage"],
+        totSFoulsOn: json["tot_sFoulsOn"],
+        totSFoulsPersonal: json["tot_sFoulsPersonal"],
+        totSFoulsTeam: json["tot_sFoulsTeam"],
+        totSFreeThrowsAttempted: json["tot_sFreeThrowsAttempted"],
+        totSFreeThrowsMade: json["tot_sFreeThrowsMade"],
+        totSFreeThrowsPercentage: json["tot_sFreeThrowsPercentage"],
+        totSLeadChanges: json["tot_sLeadChanges"],
+        totSMinutes: json["tot_sMinutes"],
+        totSPoints: json["tot_sPoints"],
+        totSPointsFastBreak: json["tot_sPointsFastBreak"],
+        totSPointsFromTurnovers: json["tot_sPointsFromTurnovers"],
+        totSPointsInThePaint: json["tot_sPointsInThePaint"],
+        totSPointsSecondChance: json["tot_sPointsSecondChance"],
+        totSReboundsDefensive: json["tot_sReboundsDefensive"],
+        totSReboundsOffensive: json["tot_sReboundsOffensive"],
+        totSReboundsTeam: json["tot_sReboundsTeam"],
+        totSReboundsTeamDefensive: json["tot_sReboundsTeamDefensive"],
+        totSReboundsTeamOffensive: json["tot_sReboundsTeamOffensive"],
+        totSReboundsTotal: json["tot_sReboundsTotal"],
+        totSSteals: json["tot_sSteals"],
+        totSThreePointersAttempted: json["tot_sThreePointersAttempted"],
+        totSThreePointersMade: json["tot_sThreePointersMade"],
+        totSThreePointersPercentage: json["tot_sThreePointersPercentage"],
+        totSTimeLeading: json["tot_sTimeLeading"]?.toDouble(),
+        totSTimesScoresLevel: json["tot_sTimesScoresLevel"],
+        totSTurnovers: json["tot_sTurnovers"],
+        totSTurnoversTeam: json["tot_sTurnoversTeam"],
+        totSTwoPointersAttempted: json["tot_sTwoPointersAttempted"],
+        totSTwoPointersMade: json["tot_sTwoPointersMade"],
+        totSTwoPointersPercentage: json["tot_sTwoPointersPercentage"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "code": code,
+        "codeInternational": codeInternational,
+        "fouls": fouls,
+        "full_score": fullScore,
+        "lds": lds.toJson(),
+        "logo": logo,
+        "name": name,
+        "nameInternational": nameInternational,
+        "p1_score": p1Score,
+        "p2_score": p2Score,
+        "p3_score": p3Score,
+        "p4_score": p4Score,
+        "pl": Map.from(pl).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "score": score,
+        "scoring": List<dynamic>.from(scoring.map((x) => x.toJson())),
+        "shortName": shortName,
+        "shortNameInternational": shortNameInternational,
+        "shot": List<dynamic>.from(shot.map((x) => x.toJson())),
+        "timeouts": timeouts,
+        "tot_eff_1": totEff1,
+        "tot_eff_2": totEff2,
+        "tot_eff_3": totEff3,
+        "tot_eff_4": totEff4,
+        "tot_eff_5": totEff5,
+        "tot_eff_6": totEff6,
+        "tot_eff_7": totEff7,
+        "tot_sAssists": totSAssists,
+        "tot_sBenchPoints": totSBenchPoints,
+        "tot_sBiggestLead": totSBiggestLead,
+        "tot_sBiggestScoringRun": totSBiggestScoringRun,
+        "tot_sBlocks": totSBlocks,
+        "tot_sBlocksReceived": totSBlocksReceived,
+        "tot_sFieldGoalsAttempted": totSFieldGoalsAttempted,
+        "tot_sFieldGoalsMade": totSFieldGoalsMade,
+        "tot_sFieldGoalsPercentage": totSFieldGoalsPercentage,
+        "tot_sFoulsOn": totSFoulsOn,
+        "tot_sFoulsPersonal": totSFoulsPersonal,
+        "tot_sFoulsTeam": totSFoulsTeam,
+        "tot_sFreeThrowsAttempted": totSFreeThrowsAttempted,
+        "tot_sFreeThrowsMade": totSFreeThrowsMade,
+        "tot_sFreeThrowsPercentage": totSFreeThrowsPercentage,
+        "tot_sLeadChanges": totSLeadChanges,
+        "tot_sMinutes": totSMinutes,
+        "tot_sPoints": totSPoints,
+        "tot_sPointsFastBreak": totSPointsFastBreak,
+        "tot_sPointsFromTurnovers": totSPointsFromTurnovers,
+        "tot_sPointsInThePaint": totSPointsInThePaint,
+        "tot_sPointsSecondChance": totSPointsSecondChance,
+        "tot_sReboundsDefensive": totSReboundsDefensive,
+        "tot_sReboundsOffensive": totSReboundsOffensive,
+        "tot_sReboundsTeam": totSReboundsTeam,
+        "tot_sReboundsTeamDefensive": totSReboundsTeamDefensive,
+        "tot_sReboundsTeamOffensive": totSReboundsTeamOffensive,
+        "tot_sReboundsTotal": totSReboundsTotal,
+        "tot_sSteals": totSSteals,
+        "tot_sThreePointersAttempted": totSThreePointersAttempted,
+        "tot_sThreePointersMade": totSThreePointersMade,
+        "tot_sThreePointersPercentage": totSThreePointersPercentage,
+        "tot_sTimeLeading": totSTimeLeading,
+        "tot_sTimesScoresLevel": totSTimesScoresLevel,
+        "tot_sTurnovers": totSTurnovers,
+        "tot_sTurnoversTeam": totSTurnoversTeam,
+        "tot_sTwoPointersAttempted": totSTwoPointersAttempted,
+        "tot_sTwoPointersMade": totSTwoPointersMade,
+        "tot_sTwoPointersPercentage": totSTwoPointersPercentage,
+    };
+}
+
+class Lds {
+    final Map<String, Scorer> sAssists;
+    final SBlocks sBlocks;
+    final Map<String, Scorer> sPoints;
+    final Map<String, Scorer> sReboundsTotal;
+    final Map<String, Scorer> sSteals;
+
+    Lds({
+        required this.sAssists,
+        required this.sBlocks,
+        required this.sPoints,
+        required this.sReboundsTotal,
+        required this.sSteals,
+    });
+
+    factory Lds.fromJson(Map<String, dynamic> json) => Lds(
+        sAssists: Map.from(json["sAssists"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sBlocks: SBlocks.fromJson(json["sBlocks"]),
+        sPoints: Map.from(json["sPoints"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sReboundsTotal: Map.from(json["sReboundsTotal"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sSteals: Map.from(json["sSteals"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "sAssists": Map.from(sAssists).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sBlocks": sBlocks.toJson(),
+        "sPoints": Map.from(sPoints).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sReboundsTotal": Map.from(sReboundsTotal).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sSteals": Map.from(sSteals).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+    };
+}
+
+class SBlocks {
+    final Scorer the1;
+
+    SBlocks({
+        required this.the1,
+    });
+
+    factory SBlocks.fromJson(Map<String, dynamic> json) => SBlocks(
+        the1: Scorer.fromJson(json["1"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "1": the1.toJson(),
+    };
+}
+
+class Pl {
+    final int active;
+    final int? captain;
+    final Comp? comp;
+    final int eff1;
+    final int eff2;
+    final double eff3;
+    final double eff4;
+    final int eff5;
+    final int eff6;
+    final int eff7;
+    final String familyName;
+    final FamilyNameInitial familyNameInitial;
+    final String firstName;
+    final FirstNameInitial firstNameInitial;
+    final String internationalFamilyName;
+    final FamilyNameInitial internationalFamilyNameInitial;
+    final String internationalFirstName;
+    final FirstNameInitial internationalFirstNameInitial;
+    final String name;
+    final String playingPosition;
+    final int sAssists;
+    final int sBlocks;
+    final int sBlocksReceived;
+    final int sFieldGoalsAttempted;
+    final int sFieldGoalsMade;
+    final int sFieldGoalsPercentage;
+    final int sFoulsOn;
+    final int sFoulsPersonal;
+    final int sFreeThrowsAttempted;
+    final int sFreeThrowsMade;
+    final int sFreeThrowsPercentage;
+    final dynamic sMinutes;
+    final int sPlusMinusPoints;
+    final int sPoints;
+    final int sPointsFastBreak;
+    final int sPointsInThePaint;
+    final int sPointsSecondChance;
+    final int sReboundsDefensive;
+    final int sReboundsOffensive;
+    final int sReboundsTotal;
+    final int sSteals;
+    final int sThreePointersAttempted;
+    final int sThreePointersMade;
+    final int sThreePointersPercentage;
+    final int sTurnovers;
+    final int sTwoPointersAttempted;
+    final int sTwoPointersMade;
+    final int sTwoPointersPercentage;
+    final String shirtNumber;
+    final int starter;
+
+    Pl({
+        required this.active,
+        this.captain,
+        this.comp,
+        required this.eff1,
+        required this.eff2,
+        required this.eff3,
+        required this.eff4,
+        required this.eff5,
+        required this.eff6,
+        required this.eff7,
+        required this.familyName,
+        required this.familyNameInitial,
+        required this.firstName,
+        required this.firstNameInitial,
+        required this.internationalFamilyName,
+        required this.internationalFamilyNameInitial,
+        required this.internationalFirstName,
+        required this.internationalFirstNameInitial,
+        required this.name,
+        required this.playingPosition,
+        required this.sAssists,
+        required this.sBlocks,
+        required this.sBlocksReceived,
+        required this.sFieldGoalsAttempted,
+        required this.sFieldGoalsMade,
+        required this.sFieldGoalsPercentage,
+        required this.sFoulsOn,
+        required this.sFoulsPersonal,
+        required this.sFreeThrowsAttempted,
+        required this.sFreeThrowsMade,
+        required this.sFreeThrowsPercentage,
+        required this.sMinutes,
+        required this.sPlusMinusPoints,
+        required this.sPoints,
+        required this.sPointsFastBreak,
+        required this.sPointsInThePaint,
+        required this.sPointsSecondChance,
+        required this.sReboundsDefensive,
+        required this.sReboundsOffensive,
+        required this.sReboundsTotal,
+        required this.sSteals,
+        required this.sThreePointersAttempted,
+        required this.sThreePointersMade,
+        required this.sThreePointersPercentage,
+        required this.sTurnovers,
+        required this.sTwoPointersAttempted,
+        required this.sTwoPointersMade,
+        required this.sTwoPointersPercentage,
+        required this.shirtNumber,
+        required this.starter,
+    });
+
+    factory Pl.fromJson(Map<String, dynamic> json) => Pl(
+        active: json["active"],
+        captain: json["captain"],
+        comp: json["comp"] == null ? null : Comp.fromJson(json["comp"]),
+        eff1: json["eff_1"],
+        eff2: json["eff_2"],
+        eff3: json["eff_3"]?.toDouble(),
+        eff4: json["eff_4"]?.toDouble(),
+        eff5: json["eff_5"],
+        eff6: json["eff_6"],
+        eff7: json["eff_7"],
+        familyName: json["familyName"],
+        familyNameInitial: familyNameInitialValues.map[json["familyNameInitial"]]!,
+        firstName: json["firstName"],
+        firstNameInitial: firstNameInitialValues.map[json["firstNameInitial"]]!,
+        internationalFamilyName: json["internationalFamilyName"],
+        internationalFamilyNameInitial: familyNameInitialValues.map[json["internationalFamilyNameInitial"]]!,
+        internationalFirstName: json["internationalFirstName"],
+        internationalFirstNameInitial: firstNameInitialValues.map[json["internationalFirstNameInitial"]]!,
+        name: json["name"],
+        playingPosition: json["playingPosition"],
+        sAssists: json["sAssists"],
+        sBlocks: json["sBlocks"],
+        sBlocksReceived: json["sBlocksReceived"],
+        sFieldGoalsAttempted: json["sFieldGoalsAttempted"],
+        sFieldGoalsMade: json["sFieldGoalsMade"],
+        sFieldGoalsPercentage: json["sFieldGoalsPercentage"],
+        sFoulsOn: json["sFoulsOn"],
+        sFoulsPersonal: json["sFoulsPersonal"],
+        sFreeThrowsAttempted: json["sFreeThrowsAttempted"],
+        sFreeThrowsMade: json["sFreeThrowsMade"],
+        sFreeThrowsPercentage: json["sFreeThrowsPercentage"],
+        sMinutes: json["sMinutes"],
+        sPlusMinusPoints: json["sPlusMinusPoints"],
+        sPoints: json["sPoints"],
+        sPointsFastBreak: json["sPointsFastBreak"],
+        sPointsInThePaint: json["sPointsInThePaint"],
+        sPointsSecondChance: json["sPointsSecondChance"],
+        sReboundsDefensive: json["sReboundsDefensive"],
+        sReboundsOffensive: json["sReboundsOffensive"],
+        sReboundsTotal: json["sReboundsTotal"],
+        sSteals: json["sSteals"],
+        sThreePointersAttempted: json["sThreePointersAttempted"],
+        sThreePointersMade: json["sThreePointersMade"],
+        sThreePointersPercentage: json["sThreePointersPercentage"],
+        sTurnovers: json["sTurnovers"],
+        sTwoPointersAttempted: json["sTwoPointersAttempted"],
+        sTwoPointersMade: json["sTwoPointersMade"],
+        sTwoPointersPercentage: json["sTwoPointersPercentage"],
+        shirtNumber: json["shirtNumber"],
+        starter: json["starter"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "active": active,
+        "captain": captain,
+        "comp": comp?.toJson(),
+        "eff_1": eff1,
+        "eff_2": eff2,
+        "eff_3": eff3,
+        "eff_4": eff4,
+        "eff_5": eff5,
+        "eff_6": eff6,
+        "eff_7": eff7,
+        "familyName": familyName,
+        "familyNameInitial": familyNameInitialValues.reverse[familyNameInitial],
+        "firstName": firstName,
+        "firstNameInitial": firstNameInitialValues.reverse[firstNameInitial],
+        "internationalFamilyName": internationalFamilyName,
+        "internationalFamilyNameInitial": familyNameInitialValues.reverse[internationalFamilyNameInitial],
+        "internationalFirstName": internationalFirstName,
+        "internationalFirstNameInitial": firstNameInitialValues.reverse[internationalFirstNameInitial],
+        "name": name,
+        "playingPosition": playingPosition,
+        "sAssists": sAssists,
+        "sBlocks": sBlocks,
+        "sBlocksReceived": sBlocksReceived,
+        "sFieldGoalsAttempted": sFieldGoalsAttempted,
+        "sFieldGoalsMade": sFieldGoalsMade,
+        "sFieldGoalsPercentage": sFieldGoalsPercentage,
+        "sFoulsOn": sFoulsOn,
+        "sFoulsPersonal": sFoulsPersonal,
+        "sFreeThrowsAttempted": sFreeThrowsAttempted,
+        "sFreeThrowsMade": sFreeThrowsMade,
+        "sFreeThrowsPercentage": sFreeThrowsPercentage,
+        "sMinutes": sMinutes,
+        "sPlusMinusPoints": sPlusMinusPoints,
+        "sPoints": sPoints,
+        "sPointsFastBreak": sPointsFastBreak,
+        "sPointsInThePaint": sPointsInThePaint,
+        "sPointsSecondChance": sPointsSecondChance,
+        "sReboundsDefensive": sReboundsDefensive,
+        "sReboundsOffensive": sReboundsOffensive,
+        "sReboundsTotal": sReboundsTotal,
+        "sSteals": sSteals,
+        "sThreePointersAttempted": sThreePointersAttempted,
+        "sThreePointersMade": sThreePointersMade,
+        "sThreePointersPercentage": sThreePointersPercentage,
+        "sTurnovers": sTurnovers,
+        "sTwoPointersAttempted": sTwoPointersAttempted,
+        "sTwoPointersMade": sTwoPointersMade,
+        "sTwoPointersPercentage": sTwoPointersPercentage,
+        "shirtNumber": shirtNumber,
+        "starter": starter,
+    };
+}
+
+class Comp {
+    final double sAssistsAverage;
+    final String sMinutesAverage;
+    final double sPointsAverage;
+    final double sReboundsTotalAverage;
+
+    Comp({
+        required this.sAssistsAverage,
+        required this.sMinutesAverage,
+        required this.sPointsAverage,
+        required this.sReboundsTotalAverage,
+    });
+
+    factory Comp.fromJson(Map<String, dynamic> json) => Comp(
+        sAssistsAverage: json["sAssistsAverage"]?.toDouble(),
+        sMinutesAverage: json["sMinutesAverage"],
+        sPointsAverage: json["sPointsAverage"]?.toDouble(),
+        sReboundsTotalAverage: json["sReboundsTotalAverage"]?.toDouble(),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "sAssistsAverage": sAssistsAverage,
+        "sMinutesAverage": sMinutesAverage,
+        "sPointsAverage": sPointsAverage,
+        "sReboundsTotalAverage": sReboundsTotalAverage,
+    };
+}
+
+class Shot {
+    final ActionType actionType;
+    final int p;
+    final int per;
+    final PerType perType;
+    final String player;
+    final int pno;
+    final int r;
+    final String shirtNumber;
+    final SubType subType;
+    final int tno;
+    final int x;
+    final int y;
+
+    Shot({
+        required this.actionType,
+        required this.p,
+        required this.per,
+        required this.perType,
+        required this.player,
+        required this.pno,
+        required this.r,
+        required this.shirtNumber,
+        required this.subType,
+        required this.tno,
+        required this.x,
+        required this.y,
+    });
+
+    factory Shot.fromJson(Map<String, dynamic> json) => Shot(
+        actionType: actionTypeValues.map[json["actionType"]]!,
+        p: json["p"],
+        per: json["per"],
+        perType: perTypeValues.map[json["perType"]]!,
+        player: json["player"],
+        pno: json["pno"],
+        r: json["r"],
+        shirtNumber: json["shirtNumber"],
+        subType: subTypeValues.map[json["subType"]]!,
+        tno: json["tno"],
+        x: json["x"],
+        y: json["y"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "actionType": actionTypeValues.reverse[actionType],
+        "p": p,
+        "per": per,
+        "perType": perTypeValues.reverse[perType],
+        "player": player,
+        "pno": pno,
+        "r": r,
+        "shirtNumber": shirtNumber,
+        "subType": subTypeValues.reverse[subType],
+        "tno": tno,
+        "x": x,
+        "y": y,
+    };
+}
+
+enum SubType {
+    JUMPSHOT,
+    LAYUP,
+    DUNK
+}
+
+final subTypeValues = EnumValues({
+    "jumpshot": SubType.JUMPSHOT,
+    "layup": SubType.LAYUP,
+    "dunk": SubType.DUNK
+});
+
+class Totallds {
+    final Map<String, Scorer> sAssists;
+    final Map<String, Scorer> sBlocks;
+    final Map<String, Scorer> sPoints;
+    final Map<String, Scorer> sReboundsTotal;
+    final Map<String, Scorer> sSteals;
+
+    Totallds({
+        required this.sAssists,
+        required this.sBlocks,
+        required this.sPoints,
+        required this.sReboundsTotal,
+        required this.sSteals,
+    });
+
+    factory Totallds.fromJson(Map<String, dynamic> json) => Totallds(
+        sAssists: Map.from(json["sAssists"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sBlocks: Map.from(json["sBlocks"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sPoints: Map.from(json["sPoints"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sReboundsTotal: Map.from(json["sReboundsTotal"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+        sSteals: Map.from(json["sSteals"]).map((k, v) => MapEntry<String, Scorer>(k, Scorer.fromJson(v))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "sAssists": Map.from(sAssists).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sBlocks": Map.from(sBlocks).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sPoints": Map.from(sPoints).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sReboundsTotal": Map.from(sReboundsTotal).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+        "sSteals": Map.from(sSteals).map((k, v) => MapEntry<String, dynamic>(k, v.toJson())),
+    };
+}
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/dart/test/inputs/json/priority/recursive.json/default/TopLevel.dart b/head/dart/test/inputs/json/priority/recursive.json/default/TopLevel.dart
new file mode 100644
index 0000000..4baf627
--- /dev/null
+++ b/head/dart/test/inputs/json/priority/recursive.json/default/TopLevel.dart
@@ -0,0 +1,501 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final Category category;
+    final Details details;
+    final String match;
+    final int page;
+    final List<ProductElement> product;
+    final bool schk;
+    final int totallooseoffers;
+    final int totalpages;
+    final int totalresultsavailable;
+    final int totalresultsreturned;
+
+    TopLevel({
+        required this.category,
+        required this.details,
+        required this.match,
+        required this.page,
+        required this.product,
+        required this.schk,
+        required this.totallooseoffers,
+        required this.totalpages,
+        required this.totalresultsavailable,
+        required this.totalresultsreturned,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        category: Category.fromJson(json["category"]),
+        details: Details.fromJson(json["details"]),
+        match: json["match"],
+        page: json["page"],
+        product: List<ProductElement>.from(json["product"].map((x) => ProductElement.fromJson(x))),
+        schk: json["schk"],
+        totallooseoffers: json["totallooseoffers"],
+        totalpages: json["totalpages"],
+        totalresultsavailable: json["totalresultsavailable"],
+        totalresultsreturned: json["totalresultsreturned"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "category": category.toJson(),
+        "details": details.toJson(),
+        "match": match,
+        "page": page,
+        "product": List<dynamic>.from(product.map((x) => x.toJson())),
+        "schk": schk,
+        "totallooseoffers": totallooseoffers,
+        "totalpages": totalpages,
+        "totalresultsavailable": totalresultsavailable,
+        "totalresultsreturned": totalresultsreturned,
+    };
+}
+
+class Category {
+    final bool concatenatecategoryname;
+    final bool hasoffer;
+    final int id;
+    final bool isfinal;
+    final List<LinkElement> links;
+    final String name;
+    final int parentcategoryid;
+    final CategoryThumbnail thumbnail;
+
+    Category({
+        required this.concatenatecategoryname,
+        required this.hasoffer,
+        required this.id,
+        required this.isfinal,
+        required this.links,
+        required this.name,
+        required this.parentcategoryid,
+        required this.thumbnail,
+    });
+
+    factory Category.fromJson(Map<String, dynamic> json) => Category(
+        concatenatecategoryname: json["concatenatecategoryname"],
+        hasoffer: json["hasoffer"],
+        id: json["id"],
+        isfinal: json["isfinal"],
+        links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
+        name: json["name"],
+        parentcategoryid: json["parentcategoryid"],
+        thumbnail: CategoryThumbnail.fromJson(json["thumbnail"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "concatenatecategoryname": concatenatecategoryname,
+        "hasoffer": hasoffer,
+        "id": id,
+        "isfinal": isfinal,
+        "links": List<dynamic>.from(links.map((x) => x.toJson())),
+        "name": name,
+        "parentcategoryid": parentcategoryid,
+        "thumbnail": thumbnail.toJson(),
+    };
+}
+
+class LinkElement {
+    final LinkLink link;
+
+    LinkElement({
+        required this.link,
+    });
+
+    factory LinkElement.fromJson(Map<String, dynamic> json) => LinkElement(
+        link: LinkLink.fromJson(json["link"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "link": link.toJson(),
+    };
+}
+
+class LinkLink {
+    final String type;
+    final String url;
+
+    LinkLink({
+        required this.type,
+        required this.url,
+    });
+
+    factory LinkLink.fromJson(Map<String, dynamic> json) => LinkLink(
+        type: json["type"],
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "type": type,
+        "url": url,
+    };
+}
+
+class CategoryThumbnail {
+    final String url;
+
+    CategoryThumbnail({
+        required this.url,
+    });
+
+    factory CategoryThumbnail.fromJson(Map<String, dynamic> json) => CategoryThumbnail(
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "url": url,
+    };
+}
+
+class Details {
+    final String applicationid;
+    final String applicationversion;
+    final int code;
+    final Date date;
+    final int elapsedtime;
+    final String message;
+    final String status;
+
+    Details({
+        required this.applicationid,
+        required this.applicationversion,
+        required this.code,
+        required this.date,
+        required this.elapsedtime,
+        required this.message,
+        required this.status,
+    });
+
+    factory Details.fromJson(Map<String, dynamic> json) => Details(
+        applicationid: json["applicationid"],
+        applicationversion: json["applicationversion"],
+        code: json["code"],
+        date: Date.fromJson(json["date"]),
+        elapsedtime: json["elapsedtime"],
+        message: json["message"],
+        status: json["status"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "applicationid": applicationid,
+        "applicationversion": applicationversion,
+        "code": code,
+        "date": date.toJson(),
+        "elapsedtime": elapsedtime,
+        "message": message,
+        "status": status,
+    };
+}
+
+class Date {
+    final int day;
+    final Eonandyear eonandyear;
+    final int hour;
+    final int millisecond;
+    final int minute;
+    final int month;
+    final int second;
+    final int timezone;
+    final bool valid;
+    final Xmlschematype xmlschematype;
+    final int year;
+
+    Date({
+        required this.day,
+        required this.eonandyear,
+        required this.hour,
+        required this.millisecond,
+        required this.minute,
+        required this.month,
+        required this.second,
+        required this.timezone,
+        required this.valid,
+        required this.xmlschematype,
+        required this.year,
+    });
+
+    factory Date.fromJson(Map<String, dynamic> json) => Date(
+        day: json["day"],
+        eonandyear: Eonandyear.fromJson(json["eonandyear"]),
+        hour: json["hour"],
+        millisecond: json["millisecond"],
+        minute: json["minute"],
+        month: json["month"],
+        second: json["second"],
+        timezone: json["timezone"],
+        valid: json["valid"],
+        xmlschematype: Xmlschematype.fromJson(json["xmlschematype"]),
+        year: json["year"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "day": day,
+        "eonandyear": eonandyear.toJson(),
+        "hour": hour,
+        "millisecond": millisecond,
+        "minute": minute,
+        "month": month,
+        "second": second,
+        "timezone": timezone,
+        "valid": valid,
+        "xmlschematype": xmlschematype.toJson(),
+        "year": year,
+    };
+}
+
+class Eonandyear {
+    final int lowestsetbit;
+
+    Eonandyear({
+        required this.lowestsetbit,
+    });
+
+    factory Eonandyear.fromJson(Map<String, dynamic> json) => Eonandyear(
+        lowestsetbit: json["lowestsetbit"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "lowestsetbit": lowestsetbit,
+    };
+}
+
+class Xmlschematype {
+    final String localpart;
+    final String namespaceuri;
+    final String prefix;
+
+    Xmlschematype({
+        required this.localpart,
+        required this.namespaceuri,
+        required this.prefix,
+    });
+
+    factory Xmlschematype.fromJson(Map<String, dynamic> json) => Xmlschematype(
+        localpart: json["localpart"],
+        namespaceuri: json["namespaceuri"],
+        prefix: json["prefix"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "localpart": localpart,
+        "namespaceuri": namespaceuri,
+        "prefix": prefix,
+    };
+}
+
+class ProductElement {
+    final ProductProduct product;
+
+    ProductElement({
+        required this.product,
+    });
+
+    factory ProductElement.fromJson(Map<String, dynamic> json) => ProductElement(
+        product: ProductProduct.fromJson(json["product"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "product": product.toJson(),
+    };
+}
+
+class ProductProduct {
+    final int categoryid;
+    final Currency currency;
+    final bool eco;
+    final bool fulldescription;
+    final bool hasmetasearch;
+    final int id;
+    final List<LinkElement> links;
+    final int numoffers;
+    final String pricemax;
+    final String pricemin;
+    final String productname;
+    final int quantity;
+    final Rating rating;
+    final Specification specification;
+    final FormatsClass thumbnail;
+    final int totalsellers;
+
+    ProductProduct({
+        required this.categoryid,
+        required this.currency,
+        required this.eco,
+        required this.fulldescription,
+        required this.hasmetasearch,
+        required this.id,
+        required this.links,
+        required this.numoffers,
+        required this.pricemax,
+        required this.pricemin,
+        required this.productname,
+        required this.quantity,
+        required this.rating,
+        required this.specification,
+        required this.thumbnail,
+        required this.totalsellers,
+    });
+
+    factory ProductProduct.fromJson(Map<String, dynamic> json) => ProductProduct(
+        categoryid: json["categoryid"],
+        currency: Currency.fromJson(json["currency"]),
+        eco: json["eco"],
+        fulldescription: json["fulldescription"],
+        hasmetasearch: json["hasmetasearch"],
+        id: json["id"],
+        links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
+        numoffers: json["numoffers"],
+        pricemax: json["pricemax"],
+        pricemin: json["pricemin"],
+        productname: json["productname"],
+        quantity: json["quantity"],
+        rating: Rating.fromJson(json["rating"]),
+        specification: Specification.fromJson(json["specification"]),
+        thumbnail: FormatsClass.fromJson(json["thumbnail"]),
+        totalsellers: json["totalsellers"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "categoryid": categoryid,
+        "currency": currency.toJson(),
+        "eco": eco,
+        "fulldescription": fulldescription,
+        "hasmetasearch": hasmetasearch,
+        "id": id,
+        "links": List<dynamic>.from(links.map((x) => x.toJson())),
+        "numoffers": numoffers,
+        "pricemax": pricemax,
+        "pricemin": pricemin,
+        "productname": productname,
+        "quantity": quantity,
+        "rating": rating.toJson(),
+        "specification": specification.toJson(),
+        "thumbnail": thumbnail.toJson(),
+        "totalsellers": totalsellers,
+    };
+}
+
+class Currency {
+    final String abbreviation;
+
+    Currency({
+        required this.abbreviation,
+    });
+
+    factory Currency.fromJson(Map<String, dynamic> json) => Currency(
+        abbreviation: json["abbreviation"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "abbreviation": abbreviation,
+    };
+}
+
+class Rating {
+    final Useraveragerating useraveragerating;
+
+    Rating({
+        required this.useraveragerating,
+    });
+
+    factory Rating.fromJson(Map<String, dynamic> json) => Rating(
+        useraveragerating: Useraveragerating.fromJson(json["useraveragerating"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "useraveragerating": useraveragerating.toJson(),
+    };
+}
+
+class Useraveragerating {
+    final List<LinkElement> links;
+    final int numcomments;
+    final String rating;
+
+    Useraveragerating({
+        required this.links,
+        required this.numcomments,
+        required this.rating,
+    });
+
+    factory Useraveragerating.fromJson(Map<String, dynamic> json) => Useraveragerating(
+        links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
+        numcomments: json["numcomments"],
+        rating: json["rating"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "links": List<dynamic>.from(links.map((x) => x.toJson())),
+        "numcomments": numcomments,
+        "rating": rating,
+    };
+}
+
+class Specification {
+    final List<LinkElement> links;
+
+    Specification({
+        required this.links,
+    });
+
+    factory Specification.fromJson(Map<String, dynamic> json) => Specification(
+        links: List<LinkElement>.from(json["links"].map((x) => LinkElement.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "links": List<dynamic>.from(links.map((x) => x.toJson())),
+    };
+}
+
+class Format {
+    final FormatsClass formats;
+
+    Format({
+        required this.formats,
+    });
+
+    factory Format.fromJson(Map<String, dynamic> json) => Format(
+        formats: FormatsClass.fromJson(json["formats"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "formats": formats.toJson(),
+    };
+}
+
+class FormatsClass {
+    final List<Format>? formats;
+    final int height;
+    final String url;
+    final int width;
+
+    FormatsClass({
+        this.formats,
+        required this.height,
+        required this.url,
+        required this.width,
+    });
+
+    factory FormatsClass.fromJson(Map<String, dynamic> json) => FormatsClass(
+        formats: json["formats"] == null ? null : List<Format>.from(json["formats"]!.map((x) => Format.fromJson(x))),
+        height: json["height"],
+        url: json["url"],
+        width: json["width"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "formats": formats == null ? null : List<dynamic>.from(formats!.map((x) => x.toJson())),
+        "height": height,
+        "url": url,
+        "width": width,
+    };
+}
diff --git a/head/dart/test/inputs/json/samples/github-events.json/default/TopLevel.dart b/head/dart/test/inputs/json/samples/github-events.json/default/TopLevel.dart
new file mode 100644
index 0000000..e8eb5a9
--- /dev/null
+++ b/head/dart/test/inputs/json/samples/github-events.json/default/TopLevel.dart
@@ -0,0 +1,1175 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+List<TopLevel> topLevelFromJson(String str) => List<TopLevel>.from(json.decode(str).map((x) => TopLevel.fromJson(x)));
+
+String topLevelToJson(List<TopLevel> data) => json.encode(List<dynamic>.from(data.map((x) => x.toJson())));
+
+class TopLevel {
+    final Actor actor;
+    final DateTime createdAt;
+    final String id;
+    final Actor? org;
+    final Payload payload;
+    final bool public;
+    final TopLevelRepo repo;
+    final String type;
+
+    TopLevel({
+        required this.actor,
+        required this.createdAt,
+        required this.id,
+        this.org,
+        required this.payload,
+        required this.public,
+        required this.repo,
+        required this.type,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        actor: Actor.fromJson(json["actor"]),
+        createdAt: DateTime.parse(json["created_at"]),
+        id: json["id"],
+        org: json["org"] == null ? null : Actor.fromJson(json["org"]),
+        payload: Payload.fromJson(json["payload"]),
+        public: json["public"],
+        repo: TopLevelRepo.fromJson(json["repo"]),
+        type: json["type"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "actor": actor.toJson(),
+        "created_at": createdAt.toIso8601String(),
+        "id": id,
+        "org": org?.toJson(),
+        "payload": payload.toJson(),
+        "public": public,
+        "repo": repo.toJson(),
+        "type": type,
+    };
+}
+
+class Actor {
+    final String avatarUrl;
+    final String? displayLogin;
+    final String gravatarId;
+    final int id;
+    final String login;
+    final String url;
+
+    Actor({
+        required this.avatarUrl,
+        this.displayLogin,
+        required this.gravatarId,
+        required this.id,
+        required this.login,
+        required this.url,
+    });
+
+    factory Actor.fromJson(Map<String, dynamic> json) => Actor(
+        avatarUrl: json["avatar_url"],
+        displayLogin: json["display_login"],
+        gravatarId: json["gravatar_id"],
+        id: json["id"],
+        login: json["login"],
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "avatar_url": avatarUrl,
+        "display_login": displayLogin,
+        "gravatar_id": gravatarId,
+        "id": id,
+        "login": login,
+        "url": url,
+    };
+}
+
+class Payload {
+    final String? action;
+    final String? before;
+    final Comment? comment;
+    final List<Commit>? commits;
+    final String? description;
+    final int? distinctSize;
+    final String? head;
+    final Issue? issue;
+    final String? masterBranch;
+    final int? number;
+    final PayloadPullRequest? pullRequest;
+    final int? pushId;
+    final String? pusherType;
+    final String? ref;
+    final String? refType;
+    final int? size;
+
+    Payload({
+        this.action,
+        this.before,
+        this.comment,
+        this.commits,
+        this.description,
+        this.distinctSize,
+        this.head,
+        this.issue,
+        this.masterBranch,
+        this.number,
+        this.pullRequest,
+        this.pushId,
+        this.pusherType,
+        this.ref,
+        this.refType,
+        this.size,
+    });
+
+    factory Payload.fromJson(Map<String, dynamic> json) => Payload(
+        action: json["action"],
+        before: json["before"],
+        comment: json["comment"] == null ? null : Comment.fromJson(json["comment"]),
+        commits: json["commits"] == null ? null : List<Commit>.from(json["commits"]!.map((x) => Commit.fromJson(x))),
+        description: json["description"],
+        distinctSize: json["distinct_size"],
+        head: json["head"],
+        issue: json["issue"] == null ? null : Issue.fromJson(json["issue"]),
+        masterBranch: json["master_branch"],
+        number: json["number"],
+        pullRequest: json["pull_request"] == null ? null : PayloadPullRequest.fromJson(json["pull_request"]),
+        pushId: json["push_id"],
+        pusherType: json["pusher_type"],
+        ref: json["ref"],
+        refType: json["ref_type"],
+        size: json["size"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "action": action,
+        "before": before,
+        "comment": comment?.toJson(),
+        "commits": commits == null ? null : List<dynamic>.from(commits!.map((x) => x.toJson())),
+        "description": description,
+        "distinct_size": distinctSize,
+        "head": head,
+        "issue": issue?.toJson(),
+        "master_branch": masterBranch,
+        "number": number,
+        "pull_request": pullRequest?.toJson(),
+        "push_id": pushId,
+        "pusher_type": pusherType,
+        "ref": ref,
+        "ref_type": refType,
+        "size": size,
+    };
+}
+
+class Comment {
+    final String body;
+    final DateTime createdAt;
+    final String htmlUrl;
+    final int id;
+    final String issueUrl;
+    final DateTime updatedAt;
+    final String url;
+    final User user;
+
+    Comment({
+        required this.body,
+        required this.createdAt,
+        required this.htmlUrl,
+        required this.id,
+        required this.issueUrl,
+        required this.updatedAt,
+        required this.url,
+        required this.user,
+    });
+
+    factory Comment.fromJson(Map<String, dynamic> json) => Comment(
+        body: json["body"],
+        createdAt: DateTime.parse(json["created_at"]),
+        htmlUrl: json["html_url"],
+        id: json["id"],
+        issueUrl: json["issue_url"],
+        updatedAt: DateTime.parse(json["updated_at"]),
+        url: json["url"],
+        user: User.fromJson(json["user"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "body": body,
+        "created_at": createdAt.toIso8601String(),
+        "html_url": htmlUrl,
+        "id": id,
+        "issue_url": issueUrl,
+        "updated_at": updatedAt.toIso8601String(),
+        "url": url,
+        "user": user.toJson(),
+    };
+}
+
+class User {
+    final String avatarUrl;
+    final String eventsUrl;
+    final String followersUrl;
+    final String followingUrl;
+    final String gistsUrl;
+    final String gravatarId;
+    final String htmlUrl;
+    final int id;
+    final String login;
+    final String organizationsUrl;
+    final String receivedEventsUrl;
+    final String reposUrl;
+    final bool siteAdmin;
+    final String starredUrl;
+    final String subscriptionsUrl;
+    final Type type;
+    final String url;
+
+    User({
+        required this.avatarUrl,
+        required this.eventsUrl,
+        required this.followersUrl,
+        required this.followingUrl,
+        required this.gistsUrl,
+        required this.gravatarId,
+        required this.htmlUrl,
+        required this.id,
+        required this.login,
+        required this.organizationsUrl,
+        required this.receivedEventsUrl,
+        required this.reposUrl,
+        required this.siteAdmin,
+        required this.starredUrl,
+        required this.subscriptionsUrl,
+        required this.type,
+        required this.url,
+    });
+
+    factory User.fromJson(Map<String, dynamic> json) => User(
+        avatarUrl: json["avatar_url"],
+        eventsUrl: json["events_url"],
+        followersUrl: json["followers_url"],
+        followingUrl: json["following_url"],
+        gistsUrl: json["gists_url"],
+        gravatarId: json["gravatar_id"],
+        htmlUrl: json["html_url"],
+        id: json["id"],
+        login: json["login"],
+        organizationsUrl: json["organizations_url"],
+        receivedEventsUrl: json["received_events_url"],
+        reposUrl: json["repos_url"],
+        siteAdmin: json["site_admin"],
+        starredUrl: json["starred_url"],
+        subscriptionsUrl: json["subscriptions_url"],
+        type: typeValues.map[json["type"]]!,
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "avatar_url": avatarUrl,
+        "events_url": eventsUrl,
+        "followers_url": followersUrl,
+        "following_url": followingUrl,
+        "gists_url": gistsUrl,
+        "gravatar_id": gravatarId,
+        "html_url": htmlUrl,
+        "id": id,
+        "login": login,
+        "organizations_url": organizationsUrl,
+        "received_events_url": receivedEventsUrl,
+        "repos_url": reposUrl,
+        "site_admin": siteAdmin,
+        "starred_url": starredUrl,
+        "subscriptions_url": subscriptionsUrl,
+        "type": typeValues.reverse[type],
+        "url": url,
+    };
+}
+
+enum Type {
+    USER,
+    ORGANIZATION
+}
+
+final typeValues = EnumValues({
+    "User": Type.USER,
+    "Organization": Type.ORGANIZATION
+});
+
+class Commit {
+    final Author author;
+    final bool distinct;
+    final String message;
+    final String sha;
+    final String url;
+
+    Commit({
+        required this.author,
+        required this.distinct,
+        required this.message,
+        required this.sha,
+        required this.url,
+    });
+
+    factory Commit.fromJson(Map<String, dynamic> json) => Commit(
+        author: Author.fromJson(json["author"]),
+        distinct: json["distinct"],
+        message: json["message"],
+        sha: json["sha"],
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "author": author.toJson(),
+        "distinct": distinct,
+        "message": message,
+        "sha": sha,
+        "url": url,
+    };
+}
+
+class Author {
+    final String email;
+    final String name;
+
+    Author({
+        required this.email,
+        required this.name,
+    });
+
+    factory Author.fromJson(Map<String, dynamic> json) => Author(
+        email: json["email"],
+        name: json["name"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "email": email,
+        "name": name,
+    };
+}
+
+class Issue {
+    final dynamic assignee;
+    final List<dynamic> assignees;
+    final String body;
+    final DateTime? closedAt;
+    final int comments;
+    final String commentsUrl;
+    final DateTime createdAt;
+    final String eventsUrl;
+    final String htmlUrl;
+    final int id;
+    final List<Label> labels;
+    final String labelsUrl;
+    final bool locked;
+    final Milestone? milestone;
+    final int number;
+    final IssuePullRequest? pullRequest;
+    final String repositoryUrl;
+    final String state;
+    final String title;
+    final DateTime updatedAt;
+    final String url;
+    final User user;
+
+    Issue({
+        required this.assignee,
+        required this.assignees,
+        required this.body,
+        required this.closedAt,
+        required this.comments,
+        required this.commentsUrl,
+        required this.createdAt,
+        required this.eventsUrl,
+        required this.htmlUrl,
+        required this.id,
+        required this.labels,
+        required this.labelsUrl,
+        required this.locked,
+        required this.milestone,
+        required this.number,
+        this.pullRequest,
+        required this.repositoryUrl,
+        required this.state,
+        required this.title,
+        required this.updatedAt,
+        required this.url,
+        required this.user,
+    });
+
+    factory Issue.fromJson(Map<String, dynamic> json) => Issue(
+        assignee: json["assignee"],
+        assignees: List<dynamic>.from(json["assignees"].map((x) => x)),
+        body: json["body"],
+        closedAt: json["closed_at"] == null ? null : DateTime.parse(json["closed_at"]),
+        comments: json["comments"],
+        commentsUrl: json["comments_url"],
+        createdAt: DateTime.parse(json["created_at"]),
+        eventsUrl: json["events_url"],
+        htmlUrl: json["html_url"],
+        id: json["id"],
+        labels: List<Label>.from(json["labels"].map((x) => Label.fromJson(x))),
+        labelsUrl: json["labels_url"],
+        locked: json["locked"],
+        milestone: json["milestone"] == null ? null : Milestone.fromJson(json["milestone"]),
+        number: json["number"],
+        pullRequest: json["pull_request"] == null ? null : IssuePullRequest.fromJson(json["pull_request"]),
+        repositoryUrl: json["repository_url"],
+        state: json["state"],
+        title: json["title"],
+        updatedAt: DateTime.parse(json["updated_at"]),
+        url: json["url"],
+        user: User.fromJson(json["user"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "assignee": assignee,
+        "assignees": List<dynamic>.from(assignees.map((x) => x)),
+        "body": body,
+        "closed_at": closedAt?.toIso8601String(),
+        "comments": comments,
+        "comments_url": commentsUrl,
+        "created_at": createdAt.toIso8601String(),
+        "events_url": eventsUrl,
+        "html_url": htmlUrl,
+        "id": id,
+        "labels": List<dynamic>.from(labels.map((x) => x.toJson())),
+        "labels_url": labelsUrl,
+        "locked": locked,
+        "milestone": milestone?.toJson(),
+        "number": number,
+        "pull_request": pullRequest?.toJson(),
+        "repository_url": repositoryUrl,
+        "state": state,
+        "title": title,
+        "updated_at": updatedAt.toIso8601String(),
+        "url": url,
+        "user": user.toJson(),
+    };
+}
+
+class Label {
+    final String color;
+    final int id;
+    final bool labelDefault;
+    final String name;
+    final String url;
+
+    Label({
+        required this.color,
+        required this.id,
+        required this.labelDefault,
+        required this.name,
+        required this.url,
+    });
+
+    factory Label.fromJson(Map<String, dynamic> json) => Label(
+        color: json["color"],
+        id: json["id"],
+        labelDefault: json["default"],
+        name: json["name"],
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "color": color,
+        "id": id,
+        "default": labelDefault,
+        "name": name,
+        "url": url,
+    };
+}
+
+class Milestone {
+    final dynamic closedAt;
+    final int closedIssues;
+    final DateTime createdAt;
+    final User creator;
+    final String description;
+    final DateTime? dueOn;
+    final String htmlUrl;
+    final int id;
+    final String labelsUrl;
+    final int number;
+    final int openIssues;
+    final String state;
+    final String title;
+    final DateTime updatedAt;
+    final String url;
+
+    Milestone({
+        required this.closedAt,
+        required this.closedIssues,
+        required this.createdAt,
+        required this.creator,
+        required this.description,
+        required this.dueOn,
+        required this.htmlUrl,
+        required this.id,
+        required this.labelsUrl,
+        required this.number,
+        required this.openIssues,
+        required this.state,
+        required this.title,
+        required this.updatedAt,
+        required this.url,
+    });
+
+    factory Milestone.fromJson(Map<String, dynamic> json) => Milestone(
+        closedAt: json["closed_at"],
+        closedIssues: json["closed_issues"],
+        createdAt: DateTime.parse(json["created_at"]),
+        creator: User.fromJson(json["creator"]),
+        description: json["description"],
+        dueOn: json["due_on"] == null ? null : DateTime.parse(json["due_on"]),
+        htmlUrl: json["html_url"],
+        id: json["id"],
+        labelsUrl: json["labels_url"],
+        number: json["number"],
+        openIssues: json["open_issues"],
+        state: json["state"],
+        title: json["title"],
+        updatedAt: DateTime.parse(json["updated_at"]),
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "closed_at": closedAt,
+        "closed_issues": closedIssues,
+        "created_at": createdAt.toIso8601String(),
+        "creator": creator.toJson(),
+        "description": description,
+        "due_on": dueOn?.toIso8601String(),
+        "html_url": htmlUrl,
+        "id": id,
+        "labels_url": labelsUrl,
+        "number": number,
+        "open_issues": openIssues,
+        "state": state,
+        "title": title,
+        "updated_at": updatedAt.toIso8601String(),
+        "url": url,
+    };
+}
+
+class IssuePullRequest {
+    final String diffUrl;
+    final String htmlUrl;
+    final String patchUrl;
+    final String url;
+
+    IssuePullRequest({
+        required this.diffUrl,
+        required this.htmlUrl,
+        required this.patchUrl,
+        required this.url,
+    });
+
+    factory IssuePullRequest.fromJson(Map<String, dynamic> json) => IssuePullRequest(
+        diffUrl: json["diff_url"],
+        htmlUrl: json["html_url"],
+        patchUrl: json["patch_url"],
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "diff_url": diffUrl,
+        "html_url": htmlUrl,
+        "patch_url": patchUrl,
+        "url": url,
+    };
+}
+
+class PayloadPullRequest {
+    final int additions;
+    final dynamic assignee;
+    final List<dynamic> assignees;
+    final Base base;
+    final String body;
+    final int changedFiles;
+    final DateTime closedAt;
+    final int comments;
+    final String commentsUrl;
+    final int commits;
+    final String commitsUrl;
+    final DateTime createdAt;
+    final int deletions;
+    final String diffUrl;
+    final Base head;
+    final String htmlUrl;
+    final int id;
+    final String issueUrl;
+    final Links links;
+    final bool locked;
+    final bool maintainerCanModify;
+    final String mergeCommitSha;
+    final dynamic mergeable;
+    final String mergeableState;
+    final bool merged;
+    final DateTime mergedAt;
+    final User mergedBy;
+    final dynamic milestone;
+    final int number;
+    final String patchUrl;
+    final dynamic rebaseable;
+    final List<dynamic> requestedReviewers;
+    final String reviewCommentUrl;
+    final int reviewComments;
+    final String reviewCommentsUrl;
+    final String state;
+    final String statusesUrl;
+    final String title;
+    final DateTime updatedAt;
+    final String url;
+    final User user;
+
+    PayloadPullRequest({
+        required this.additions,
+        required this.assignee,
+        required this.assignees,
+        required this.base,
+        required this.body,
+        required this.changedFiles,
+        required this.closedAt,
+        required this.comments,
+        required this.commentsUrl,
+        required this.commits,
+        required this.commitsUrl,
+        required this.createdAt,
+        required this.deletions,
+        required this.diffUrl,
+        required this.head,
+        required this.htmlUrl,
+        required this.id,
+        required this.issueUrl,
+        required this.links,
+        required this.locked,
+        required this.maintainerCanModify,
+        required this.mergeCommitSha,
+        required this.mergeable,
+        required this.mergeableState,
+        required this.merged,
+        required this.mergedAt,
+        required this.mergedBy,
+        required this.milestone,
+        required this.number,
+        required this.patchUrl,
+        required this.rebaseable,
+        required this.requestedReviewers,
+        required this.reviewCommentUrl,
+        required this.reviewComments,
+        required this.reviewCommentsUrl,
+        required this.state,
+        required this.statusesUrl,
+        required this.title,
+        required this.updatedAt,
+        required this.url,
+        required this.user,
+    });
+
+    factory PayloadPullRequest.fromJson(Map<String, dynamic> json) => PayloadPullRequest(
+        additions: json["additions"],
+        assignee: json["assignee"],
+        assignees: List<dynamic>.from(json["assignees"].map((x) => x)),
+        base: Base.fromJson(json["base"]),
+        body: json["body"],
+        changedFiles: json["changed_files"],
+        closedAt: DateTime.parse(json["closed_at"]),
+        comments: json["comments"],
+        commentsUrl: json["comments_url"],
+        commits: json["commits"],
+        commitsUrl: json["commits_url"],
+        createdAt: DateTime.parse(json["created_at"]),
+        deletions: json["deletions"],
+        diffUrl: json["diff_url"],
+        head: Base.fromJson(json["head"]),
+        htmlUrl: json["html_url"],
+        id: json["id"],
+        issueUrl: json["issue_url"],
+        links: Links.fromJson(json["_links"]),
+        locked: json["locked"],
+        maintainerCanModify: json["maintainer_can_modify"],
+        mergeCommitSha: json["merge_commit_sha"],
+        mergeable: json["mergeable"],
+        mergeableState: json["mergeable_state"],
+        merged: json["merged"],
+        mergedAt: DateTime.parse(json["merged_at"]),
+        mergedBy: User.fromJson(json["merged_by"]),
+        milestone: json["milestone"],
+        number: json["number"],
+        patchUrl: json["patch_url"],
+        rebaseable: json["rebaseable"],
+        requestedReviewers: List<dynamic>.from(json["requested_reviewers"].map((x) => x)),
+        reviewCommentUrl: json["review_comment_url"],
+        reviewComments: json["review_comments"],
+        reviewCommentsUrl: json["review_comments_url"],
+        state: json["state"],
+        statusesUrl: json["statuses_url"],
+        title: json["title"],
+        updatedAt: DateTime.parse(json["updated_at"]),
+        url: json["url"],
+        user: User.fromJson(json["user"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "additions": additions,
+        "assignee": assignee,
+        "assignees": List<dynamic>.from(assignees.map((x) => x)),
+        "base": base.toJson(),
+        "body": body,
+        "changed_files": changedFiles,
+        "closed_at": closedAt.toIso8601String(),
+        "comments": comments,
+        "comments_url": commentsUrl,
+        "commits": commits,
+        "commits_url": commitsUrl,
+        "created_at": createdAt.toIso8601String(),
+        "deletions": deletions,
+        "diff_url": diffUrl,
+        "head": head.toJson(),
+        "html_url": htmlUrl,
+        "id": id,
+        "issue_url": issueUrl,
+        "_links": links.toJson(),
+        "locked": locked,
+        "maintainer_can_modify": maintainerCanModify,
+        "merge_commit_sha": mergeCommitSha,
+        "mergeable": mergeable,
+        "mergeable_state": mergeableState,
+        "merged": merged,
+        "merged_at": mergedAt.toIso8601String(),
+        "merged_by": mergedBy.toJson(),
+        "milestone": milestone,
+        "number": number,
+        "patch_url": patchUrl,
+        "rebaseable": rebaseable,
+        "requested_reviewers": List<dynamic>.from(requestedReviewers.map((x) => x)),
+        "review_comment_url": reviewCommentUrl,
+        "review_comments": reviewComments,
+        "review_comments_url": reviewCommentsUrl,
+        "state": state,
+        "statuses_url": statusesUrl,
+        "title": title,
+        "updated_at": updatedAt.toIso8601String(),
+        "url": url,
+        "user": user.toJson(),
+    };
+}
+
+class Base {
+    final String label;
+    final String ref;
+    final BaseRepo repo;
+    final String sha;
+    final User user;
+
+    Base({
+        required this.label,
+        required this.ref,
+        required this.repo,
+        required this.sha,
+        required this.user,
+    });
+
+    factory Base.fromJson(Map<String, dynamic> json) => Base(
+        label: json["label"],
+        ref: json["ref"],
+        repo: BaseRepo.fromJson(json["repo"]),
+        sha: json["sha"],
+        user: User.fromJson(json["user"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "label": label,
+        "ref": ref,
+        "repo": repo.toJson(),
+        "sha": sha,
+        "user": user.toJson(),
+    };
+}
+
+class BaseRepo {
+    final String archiveUrl;
+    final String assigneesUrl;
+    final String blobsUrl;
+    final String branchesUrl;
+    final String cloneUrl;
+    final String collaboratorsUrl;
+    final String commentsUrl;
+    final String commitsUrl;
+    final String compareUrl;
+    final String contentsUrl;
+    final String contributorsUrl;
+    final DateTime createdAt;
+    final String defaultBranch;
+    final String deploymentsUrl;
+    final String description;
+    final String downloadsUrl;
+    final String eventsUrl;
+    final bool fork;
+    final int forks;
+    final int forksCount;
+    final String forksUrl;
+    final String fullName;
+    final String gitCommitsUrl;
+    final String gitRefsUrl;
+    final String gitTagsUrl;
+    final String gitUrl;
+    final bool hasDownloads;
+    final bool hasIssues;
+    final bool hasPages;
+    final bool hasProjects;
+    final bool hasWiki;
+    final String homepage;
+    final String hooksUrl;
+    final String htmlUrl;
+    final int id;
+    final String issueCommentUrl;
+    final String issueEventsUrl;
+    final String issuesUrl;
+    final String keysUrl;
+    final String labelsUrl;
+    final String language;
+    final String languagesUrl;
+    final String mergesUrl;
+    final String milestonesUrl;
+    final dynamic mirrorUrl;
+    final String name;
+    final String notificationsUrl;
+    final int openIssues;
+    final int openIssuesCount;
+    final User owner;
+    final bool private;
+    final String pullsUrl;
+    final DateTime pushedAt;
+    final String releasesUrl;
+    final int size;
+    final String sshUrl;
+    final int stargazersCount;
+    final String stargazersUrl;
+    final String statusesUrl;
+    final String subscribersUrl;
+    final String subscriptionUrl;
+    final String svnUrl;
+    final String tagsUrl;
+    final String teamsUrl;
+    final String treesUrl;
+    final DateTime updatedAt;
+    final String url;
+    final int watchers;
+    final int watchersCount;
+
+    BaseRepo({
+        required this.archiveUrl,
+        required this.assigneesUrl,
+        required this.blobsUrl,
+        required this.branchesUrl,
+        required this.cloneUrl,
+        required this.collaboratorsUrl,
+        required this.commentsUrl,
+        required this.commitsUrl,
+        required this.compareUrl,
+        required this.contentsUrl,
+        required this.contributorsUrl,
+        required this.createdAt,
+        required this.defaultBranch,
+        required this.deploymentsUrl,
+        required this.description,
+        required this.downloadsUrl,
+        required this.eventsUrl,
+        required this.fork,
+        required this.forks,
+        required this.forksCount,
+        required this.forksUrl,
+        required this.fullName,
+        required this.gitCommitsUrl,
+        required this.gitRefsUrl,
+        required this.gitTagsUrl,
+        required this.gitUrl,
+        required this.hasDownloads,
+        required this.hasIssues,
+        required this.hasPages,
+        required this.hasProjects,
+        required this.hasWiki,
+        required this.homepage,
+        required this.hooksUrl,
+        required this.htmlUrl,
+        required this.id,
+        required this.issueCommentUrl,
+        required this.issueEventsUrl,
+        required this.issuesUrl,
+        required this.keysUrl,
+        required this.labelsUrl,
+        required this.language,
+        required this.languagesUrl,
+        required this.mergesUrl,
+        required this.milestonesUrl,
+        required this.mirrorUrl,
+        required this.name,
+        required this.notificationsUrl,
+        required this.openIssues,
+        required this.openIssuesCount,
+        required this.owner,
+        required this.private,
+        required this.pullsUrl,
+        required this.pushedAt,
+        required this.releasesUrl,
+        required this.size,
+        required this.sshUrl,
+        required this.stargazersCount,
+        required this.stargazersUrl,
+        required this.statusesUrl,
+        required this.subscribersUrl,
+        required this.subscriptionUrl,
+        required this.svnUrl,
+        required this.tagsUrl,
+        required this.teamsUrl,
+        required this.treesUrl,
+        required this.updatedAt,
+        required this.url,
+        required this.watchers,
+        required this.watchersCount,
+    });
+
+    factory BaseRepo.fromJson(Map<String, dynamic> json) => BaseRepo(
+        archiveUrl: json["archive_url"],
+        assigneesUrl: json["assignees_url"],
+        blobsUrl: json["blobs_url"],
+        branchesUrl: json["branches_url"],
+        cloneUrl: json["clone_url"],
+        collaboratorsUrl: json["collaborators_url"],
+        commentsUrl: json["comments_url"],
+        commitsUrl: json["commits_url"],
+        compareUrl: json["compare_url"],
+        contentsUrl: json["contents_url"],
+        contributorsUrl: json["contributors_url"],
+        createdAt: DateTime.parse(json["created_at"]),
+        defaultBranch: json["default_branch"],
+        deploymentsUrl: json["deployments_url"],
+        description: json["description"],
+        downloadsUrl: json["downloads_url"],
+        eventsUrl: json["events_url"],
+        fork: json["fork"],
+        forks: json["forks"],
+        forksCount: json["forks_count"],
+        forksUrl: json["forks_url"],
+        fullName: json["full_name"],
+        gitCommitsUrl: json["git_commits_url"],
+        gitRefsUrl: json["git_refs_url"],
+        gitTagsUrl: json["git_tags_url"],
+        gitUrl: json["git_url"],
+        hasDownloads: json["has_downloads"],
+        hasIssues: json["has_issues"],
+        hasPages: json["has_pages"],
+        hasProjects: json["has_projects"],
+        hasWiki: json["has_wiki"],
+        homepage: json["homepage"],
+        hooksUrl: json["hooks_url"],
+        htmlUrl: json["html_url"],
+        id: json["id"],
+        issueCommentUrl: json["issue_comment_url"],
+        issueEventsUrl: json["issue_events_url"],
+        issuesUrl: json["issues_url"],
+        keysUrl: json["keys_url"],
+        labelsUrl: json["labels_url"],
+        language: json["language"],
+        languagesUrl: json["languages_url"],
+        mergesUrl: json["merges_url"],
+        milestonesUrl: json["milestones_url"],
+        mirrorUrl: json["mirror_url"],
+        name: json["name"],
+        notificationsUrl: json["notifications_url"],
+        openIssues: json["open_issues"],
+        openIssuesCount: json["open_issues_count"],
+        owner: User.fromJson(json["owner"]),
+        private: json["private"],
+        pullsUrl: json["pulls_url"],
+        pushedAt: DateTime.parse(json["pushed_at"]),
+        releasesUrl: json["releases_url"],
+        size: json["size"],
+        sshUrl: json["ssh_url"],
+        stargazersCount: json["stargazers_count"],
+        stargazersUrl: json["stargazers_url"],
+        statusesUrl: json["statuses_url"],
+        subscribersUrl: json["subscribers_url"],
+        subscriptionUrl: json["subscription_url"],
+        svnUrl: json["svn_url"],
+        tagsUrl: json["tags_url"],
+        teamsUrl: json["teams_url"],
+        treesUrl: json["trees_url"],
+        updatedAt: DateTime.parse(json["updated_at"]),
+        url: json["url"],
+        watchers: json["watchers"],
+        watchersCount: json["watchers_count"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "archive_url": archiveUrl,
+        "assignees_url": assigneesUrl,
+        "blobs_url": blobsUrl,
+        "branches_url": branchesUrl,
+        "clone_url": cloneUrl,
+        "collaborators_url": collaboratorsUrl,
+        "comments_url": commentsUrl,
+        "commits_url": commitsUrl,
+        "compare_url": compareUrl,
+        "contents_url": contentsUrl,
+        "contributors_url": contributorsUrl,
+        "created_at": createdAt.toIso8601String(),
+        "default_branch": defaultBranch,
+        "deployments_url": deploymentsUrl,
+        "description": description,
+        "downloads_url": downloadsUrl,
+        "events_url": eventsUrl,
+        "fork": fork,
+        "forks": forks,
+        "forks_count": forksCount,
+        "forks_url": forksUrl,
+        "full_name": fullName,
+        "git_commits_url": gitCommitsUrl,
+        "git_refs_url": gitRefsUrl,
+        "git_tags_url": gitTagsUrl,
+        "git_url": gitUrl,
+        "has_downloads": hasDownloads,
+        "has_issues": hasIssues,
+        "has_pages": hasPages,
+        "has_projects": hasProjects,
+        "has_wiki": hasWiki,
+        "homepage": homepage,
+        "hooks_url": hooksUrl,
+        "html_url": htmlUrl,
+        "id": id,
+        "issue_comment_url": issueCommentUrl,
+        "issue_events_url": issueEventsUrl,
+        "issues_url": issuesUrl,
+        "keys_url": keysUrl,
+        "labels_url": labelsUrl,
+        "language": language,
+        "languages_url": languagesUrl,
+        "merges_url": mergesUrl,
+        "milestones_url": milestonesUrl,
+        "mirror_url": mirrorUrl,
+        "name": name,
+        "notifications_url": notificationsUrl,
+        "open_issues": openIssues,
+        "open_issues_count": openIssuesCount,
+        "owner": owner.toJson(),
+        "private": private,
+        "pulls_url": pullsUrl,
+        "pushed_at": pushedAt.toIso8601String(),
+        "releases_url": releasesUrl,
+        "size": size,
+        "ssh_url": sshUrl,
+        "stargazers_count": stargazersCount,
+        "stargazers_url": stargazersUrl,
+        "statuses_url": statusesUrl,
+        "subscribers_url": subscribersUrl,
+        "subscription_url": subscriptionUrl,
+        "svn_url": svnUrl,
+        "tags_url": tagsUrl,
+        "teams_url": teamsUrl,
+        "trees_url": treesUrl,
+        "updated_at": updatedAt.toIso8601String(),
+        "url": url,
+        "watchers": watchers,
+        "watchers_count": watchersCount,
+    };
+}
+
+class Links {
+    final Comments comments;
+    final Comments commits;
+    final Comments html;
+    final Comments issue;
+    final Comments reviewComment;
+    final Comments reviewComments;
+    final Comments self;
+    final Comments statuses;
+
+    Links({
+        required this.comments,
+        required this.commits,
+        required this.html,
+        required this.issue,
+        required this.reviewComment,
+        required this.reviewComments,
+        required this.self,
+        required this.statuses,
+    });
+
+    factory Links.fromJson(Map<String, dynamic> json) => Links(
+        comments: Comments.fromJson(json["comments"]),
+        commits: Comments.fromJson(json["commits"]),
+        html: Comments.fromJson(json["html"]),
+        issue: Comments.fromJson(json["issue"]),
+        reviewComment: Comments.fromJson(json["review_comment"]),
+        reviewComments: Comments.fromJson(json["review_comments"]),
+        self: Comments.fromJson(json["self"]),
+        statuses: Comments.fromJson(json["statuses"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "comments": comments.toJson(),
+        "commits": commits.toJson(),
+        "html": html.toJson(),
+        "issue": issue.toJson(),
+        "review_comment": reviewComment.toJson(),
+        "review_comments": reviewComments.toJson(),
+        "self": self.toJson(),
+        "statuses": statuses.toJson(),
+    };
+}
+
+class Comments {
+    final String href;
+
+    Comments({
+        required this.href,
+    });
+
+    factory Comments.fromJson(Map<String, dynamic> json) => Comments(
+        href: json["href"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "href": href,
+    };
+}
+
+class TopLevelRepo {
+    final int id;
+    final String name;
+    final String url;
+
+    TopLevelRepo({
+        required this.id,
+        required this.name,
+        required this.url,
+    });
+
+    factory TopLevelRepo.fromJson(Map<String, dynamic> json) => TopLevelRepo(
+        id: json["id"],
+        name: json["name"],
+        url: json["url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "id": id,
+        "name": name,
+        "url": url,
+    };
+}
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/dart/test/inputs/json/samples/pokedex.json/default/TopLevel.dart b/head/dart/test/inputs/json/samples/pokedex.json/default/TopLevel.dart
new file mode 100644
index 0000000..758ba3f
--- /dev/null
+++ b/head/dart/test/inputs/json/samples/pokedex.json/default/TopLevel.dart
@@ -0,0 +1,195 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<Pokemon> pokemon;
+
+    TopLevel({
+        required this.pokemon,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        pokemon: List<Pokemon>.from(json["pokemon"].map((x) => Pokemon.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "pokemon": List<dynamic>.from(pokemon.map((x) => x.toJson())),
+    };
+}
+
+class Pokemon {
+    final double avgSpawns;
+    final String candy;
+    final int? candyCount;
+    final Egg egg;
+    final String height;
+    final int id;
+    final String img;
+    final List<double>? multipliers;
+    final String name;
+    final List<Evolution>? nextEvolution;
+    final String num;
+    final List<Evolution>? prevEvolution;
+    final double spawnChance;
+    final String spawnTime;
+    final List<Type> type;
+    final List<Type> weaknesses;
+    final String weight;
+
+    Pokemon({
+        required this.avgSpawns,
+        required this.candy,
+        this.candyCount,
+        required this.egg,
+        required this.height,
+        required this.id,
+        required this.img,
+        required this.multipliers,
+        required this.name,
+        this.nextEvolution,
+        required this.num,
+        this.prevEvolution,
+        required this.spawnChance,
+        required this.spawnTime,
+        required this.type,
+        required this.weaknesses,
+        required this.weight,
+    });
+
+    factory Pokemon.fromJson(Map<String, dynamic> json) => Pokemon(
+        avgSpawns: json["avg_spawns"]?.toDouble(),
+        candy: json["candy"],
+        candyCount: json["candy_count"],
+        egg: eggValues.map[json["egg"]]!,
+        height: json["height"],
+        id: json["id"],
+        img: json["img"],
+        multipliers: json["multipliers"] == null ? null : List<double>.from(json["multipliers"]!.map((x) => x?.toDouble())),
+        name: json["name"],
+        nextEvolution: json["next_evolution"] == null ? null : List<Evolution>.from(json["next_evolution"]!.map((x) => Evolution.fromJson(x))),
+        num: json["num"],
+        prevEvolution: json["prev_evolution"] == null ? null : List<Evolution>.from(json["prev_evolution"]!.map((x) => Evolution.fromJson(x))),
+        spawnChance: json["spawn_chance"]?.toDouble(),
+        spawnTime: json["spawn_time"],
+        type: List<Type>.from(json["type"].map((x) => typeValues.map[x]!)),
+        weaknesses: List<Type>.from(json["weaknesses"].map((x) => typeValues.map[x]!)),
+        weight: json["weight"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "avg_spawns": avgSpawns,
+        "candy": candy,
+        "candy_count": candyCount,
+        "egg": eggValues.reverse[egg],
+        "height": height,
+        "id": id,
+        "img": img,
+        "multipliers": multipliers == null ? null : List<dynamic>.from(multipliers!.map((x) => x)),
+        "name": name,
+        "next_evolution": nextEvolution == null ? null : List<dynamic>.from(nextEvolution!.map((x) => x.toJson())),
+        "num": num,
+        "prev_evolution": prevEvolution == null ? null : List<dynamic>.from(prevEvolution!.map((x) => x.toJson())),
+        "spawn_chance": spawnChance,
+        "spawn_time": spawnTime,
+        "type": List<dynamic>.from(type.map((x) => typeValues.reverse[x])),
+        "weaknesses": List<dynamic>.from(weaknesses.map((x) => typeValues.reverse[x])),
+        "weight": weight,
+    };
+}
+
+enum Egg {
+    THE_2_KM,
+    NOT_IN_EGGS,
+    THE_5_KM,
+    THE_10_KM,
+    OMANYTE_CANDY
+}
+
+final eggValues = EnumValues({
+    "2 km": Egg.THE_2_KM,
+    "Not in Eggs": Egg.NOT_IN_EGGS,
+    "5 km": Egg.THE_5_KM,
+    "10 km": Egg.THE_10_KM,
+    "Omanyte Candy": Egg.OMANYTE_CANDY
+});
+
+class Evolution {
+    final String name;
+    final String num;
+
+    Evolution({
+        required this.name,
+        required this.num,
+    });
+
+    factory Evolution.fromJson(Map<String, dynamic> json) => Evolution(
+        name: json["name"],
+        num: json["num"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "name": name,
+        "num": num,
+    };
+}
+
+enum Type {
+    FIRE,
+    ICE,
+    FLYING,
+    PSYCHIC,
+    WATER,
+    GROUND,
+    ROCK,
+    ELECTRIC,
+    GRASS,
+    FIGHTING,
+    POISON,
+    BUG,
+    FAIRY,
+    GHOST,
+    DARK,
+    STEEL,
+    DRAGON,
+    NORMAL
+}
+
+final typeValues = EnumValues({
+    "Fire": Type.FIRE,
+    "Ice": Type.ICE,
+    "Flying": Type.FLYING,
+    "Psychic": Type.PSYCHIC,
+    "Water": Type.WATER,
+    "Ground": Type.GROUND,
+    "Rock": Type.ROCK,
+    "Electric": Type.ELECTRIC,
+    "Grass": Type.GRASS,
+    "Fighting": Type.FIGHTING,
+    "Poison": Type.POISON,
+    "Bug": Type.BUG,
+    "Fairy": Type.FAIRY,
+    "Ghost": Type.GHOST,
+    "Dark": Type.DARK,
+    "Steel": Type.STEEL,
+    "Dragon": Type.DRAGON,
+    "Normal": Type.NORMAL
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/dart/test/inputs/json/samples/reddit.json/default/TopLevel.dart b/head/dart/test/inputs/json/samples/reddit.json/default/TopLevel.dart
new file mode 100644
index 0000000..2879a3f
--- /dev/null
+++ b/head/dart/test/inputs/json/samples/reddit.json/default/TopLevel.dart
@@ -0,0 +1,559 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final TopLevelData data;
+    final String kind;
+
+    TopLevel({
+        required this.data,
+        required this.kind,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        data: TopLevelData.fromJson(json["data"]),
+        kind: json["kind"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "data": data.toJson(),
+        "kind": kind,
+    };
+}
+
+class TopLevelData {
+    final String after;
+    final dynamic before;
+    final List<Child> children;
+    final String modhash;
+
+    TopLevelData({
+        required this.after,
+        required this.before,
+        required this.children,
+        required this.modhash,
+    });
+
+    factory TopLevelData.fromJson(Map<String, dynamic> json) => TopLevelData(
+        after: json["after"],
+        before: json["before"],
+        children: List<Child>.from(json["children"].map((x) => Child.fromJson(x))),
+        modhash: json["modhash"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "after": after,
+        "before": before,
+        "children": List<dynamic>.from(children.map((x) => x.toJson())),
+        "modhash": modhash,
+    };
+}
+
+class Child {
+    final ChildData data;
+    final Kind kind;
+
+    Child({
+        required this.data,
+        required this.kind,
+    });
+
+    factory Child.fromJson(Map<String, dynamic> json) => Child(
+        data: ChildData.fromJson(json["data"]),
+        kind: kindValues.map[json["kind"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "data": data.toJson(),
+        "kind": kindValues.reverse[kind],
+    };
+}
+
+class ChildData {
+    final dynamic approvedAtUtc;
+    final dynamic approvedBy;
+    final bool archived;
+    final String author;
+    final String? authorFlairCssClass;
+    final String? authorFlairText;
+    final dynamic bannedAtUtc;
+    final dynamic bannedBy;
+    final bool brandSafe;
+    final bool canGild;
+    final bool canModPost;
+    final bool clicked;
+    final bool contestMode;
+    final int created;
+    final int createdUtc;
+    final String? distinguished;
+    final Domain domain;
+    final int downs;
+    final bool edited;
+    final int gilded;
+    final bool hidden;
+    final bool hideScore;
+    final String id;
+    final bool isSelf;
+    final bool isVideo;
+    final dynamic likes;
+    final String? linkFlairCssClass;
+    final String? linkFlairText;
+    final bool locked;
+    final dynamic media;
+    final MediaEmbed mediaEmbed;
+    final List<dynamic> modReports;
+    final String name;
+    final int numComments;
+    final dynamic numReports;
+    final bool over18;
+    final WhitelistStatus parentWhitelistStatus;
+    final String permalink;
+    final PostHint postHint;
+    final Preview preview;
+    final bool quarantine;
+    final dynamic removalReason;
+    final dynamic reportReasons;
+    final bool saved;
+    final int score;
+    final dynamic secureMedia;
+    final MediaEmbed secureMediaEmbed;
+    final String selftext;
+    final dynamic selftextHtml;
+    final bool spoiler;
+    final bool stickied;
+    final Subreddit subreddit;
+    final SubredditId subredditId;
+    final SubredditNamePrefixed subredditNamePrefixed;
+    final SubredditType subredditType;
+    final dynamic suggestedSort;
+    final String thumbnail;
+    final int thumbnailHeight;
+    final int thumbnailWidth;
+    final String title;
+    final int ups;
+    final String url;
+    final List<dynamic> userReports;
+    final dynamic viewCount;
+    final bool visited;
+    final WhitelistStatus whitelistStatus;
+
+    ChildData({
+        required this.approvedAtUtc,
+        required this.approvedBy,
+        required this.archived,
+        required this.author,
+        required this.authorFlairCssClass,
+        required this.authorFlairText,
+        required this.bannedAtUtc,
+        required this.bannedBy,
+        required this.brandSafe,
+        required this.canGild,
+        required this.canModPost,
+        required this.clicked,
+        required this.contestMode,
+        required this.created,
+        required this.createdUtc,
+        required this.distinguished,
+        required this.domain,
+        required this.downs,
+        required this.edited,
+        required this.gilded,
+        required this.hidden,
+        required this.hideScore,
+        required this.id,
+        required this.isSelf,
+        required this.isVideo,
+        required this.likes,
+        required this.linkFlairCssClass,
+        required this.linkFlairText,
+        required this.locked,
+        required this.media,
+        required this.mediaEmbed,
+        required this.modReports,
+        required this.name,
+        required this.numComments,
+        required this.numReports,
+        required this.over18,
+        required this.parentWhitelistStatus,
+        required this.permalink,
+        required this.postHint,
+        required this.preview,
+        required this.quarantine,
+        required this.removalReason,
+        required this.reportReasons,
+        required this.saved,
+        required this.score,
+        required this.secureMedia,
+        required this.secureMediaEmbed,
+        required this.selftext,
+        required this.selftextHtml,
+        required this.spoiler,
+        required this.stickied,
+        required this.subreddit,
+        required this.subredditId,
+        required this.subredditNamePrefixed,
+        required this.subredditType,
+        required this.suggestedSort,
+        required this.thumbnail,
+        required this.thumbnailHeight,
+        required this.thumbnailWidth,
+        required this.title,
+        required this.ups,
+        required this.url,
+        required this.userReports,
+        required this.viewCount,
+        required this.visited,
+        required this.whitelistStatus,
+    });
+
+    factory ChildData.fromJson(Map<String, dynamic> json) => ChildData(
+        approvedAtUtc: json["approved_at_utc"],
+        approvedBy: json["approved_by"],
+        archived: json["archived"],
+        author: json["author"],
+        authorFlairCssClass: json["author_flair_css_class"],
+        authorFlairText: json["author_flair_text"],
+        bannedAtUtc: json["banned_at_utc"],
+        bannedBy: json["banned_by"],
+        brandSafe: json["brand_safe"],
+        canGild: json["can_gild"],
+        canModPost: json["can_mod_post"],
+        clicked: json["clicked"],
+        contestMode: json["contest_mode"],
+        created: json["created"],
+        createdUtc: json["created_utc"],
+        distinguished: json["distinguished"],
+        domain: domainValues.map[json["domain"]]!,
+        downs: json["downs"],
+        edited: json["edited"],
+        gilded: json["gilded"],
+        hidden: json["hidden"],
+        hideScore: json["hide_score"],
+        id: json["id"],
+        isSelf: json["is_self"],
+        isVideo: json["is_video"],
+        likes: json["likes"],
+        linkFlairCssClass: json["link_flair_css_class"],
+        linkFlairText: json["link_flair_text"],
+        locked: json["locked"],
+        media: json["media"],
+        mediaEmbed: MediaEmbed.fromJson(json["media_embed"]),
+        modReports: List<dynamic>.from(json["mod_reports"].map((x) => x)),
+        name: json["name"],
+        numComments: json["num_comments"],
+        numReports: json["num_reports"],
+        over18: json["over_18"],
+        parentWhitelistStatus: whitelistStatusValues.map[json["parent_whitelist_status"]]!,
+        permalink: json["permalink"],
+        postHint: postHintValues.map[json["post_hint"]]!,
+        preview: Preview.fromJson(json["preview"]),
+        quarantine: json["quarantine"],
+        removalReason: json["removal_reason"],
+        reportReasons: json["report_reasons"],
+        saved: json["saved"],
+        score: json["score"],
+        secureMedia: json["secure_media"],
+        secureMediaEmbed: MediaEmbed.fromJson(json["secure_media_embed"]),
+        selftext: json["selftext"],
+        selftextHtml: json["selftext_html"],
+        spoiler: json["spoiler"],
+        stickied: json["stickied"],
+        subreddit: subredditValues.map[json["subreddit"]]!,
+        subredditId: subredditIdValues.map[json["subreddit_id"]]!,
+        subredditNamePrefixed: subredditNamePrefixedValues.map[json["subreddit_name_prefixed"]]!,
+        subredditType: subredditTypeValues.map[json["subreddit_type"]]!,
+        suggestedSort: json["suggested_sort"],
+        thumbnail: json["thumbnail"],
+        thumbnailHeight: json["thumbnail_height"],
+        thumbnailWidth: json["thumbnail_width"],
+        title: json["title"],
+        ups: json["ups"],
+        url: json["url"],
+        userReports: List<dynamic>.from(json["user_reports"].map((x) => x)),
+        viewCount: json["view_count"],
+        visited: json["visited"],
+        whitelistStatus: whitelistStatusValues.map[json["whitelist_status"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "approved_at_utc": approvedAtUtc,
+        "approved_by": approvedBy,
+        "archived": archived,
+        "author": author,
+        "author_flair_css_class": authorFlairCssClass,
+        "author_flair_text": authorFlairText,
+        "banned_at_utc": bannedAtUtc,
+        "banned_by": bannedBy,
+        "brand_safe": brandSafe,
+        "can_gild": canGild,
+        "can_mod_post": canModPost,
+        "clicked": clicked,
+        "contest_mode": contestMode,
+        "created": created,
+        "created_utc": createdUtc,
+        "distinguished": distinguished,
+        "domain": domainValues.reverse[domain],
+        "downs": downs,
+        "edited": edited,
+        "gilded": gilded,
+        "hidden": hidden,
+        "hide_score": hideScore,
+        "id": id,
+        "is_self": isSelf,
+        "is_video": isVideo,
+        "likes": likes,
+        "link_flair_css_class": linkFlairCssClass,
+        "link_flair_text": linkFlairText,
+        "locked": locked,
+        "media": media,
+        "media_embed": mediaEmbed.toJson(),
+        "mod_reports": List<dynamic>.from(modReports.map((x) => x)),
+        "name": name,
+        "num_comments": numComments,
+        "num_reports": numReports,
+        "over_18": over18,
+        "parent_whitelist_status": whitelistStatusValues.reverse[parentWhitelistStatus],
+        "permalink": permalink,
+        "post_hint": postHintValues.reverse[postHint],
+        "preview": preview.toJson(),
+        "quarantine": quarantine,
+        "removal_reason": removalReason,
+        "report_reasons": reportReasons,
+        "saved": saved,
+        "score": score,
+        "secure_media": secureMedia,
+        "secure_media_embed": secureMediaEmbed.toJson(),
+        "selftext": selftext,
+        "selftext_html": selftextHtml,
+        "spoiler": spoiler,
+        "stickied": stickied,
+        "subreddit": subredditValues.reverse[subreddit],
+        "subreddit_id": subredditIdValues.reverse[subredditId],
+        "subreddit_name_prefixed": subredditNamePrefixedValues.reverse[subredditNamePrefixed],
+        "subreddit_type": subredditTypeValues.reverse[subredditType],
+        "suggested_sort": suggestedSort,
+        "thumbnail": thumbnail,
+        "thumbnail_height": thumbnailHeight,
+        "thumbnail_width": thumbnailWidth,
+        "title": title,
+        "ups": ups,
+        "url": url,
+        "user_reports": List<dynamic>.from(userReports.map((x) => x)),
+        "view_count": viewCount,
+        "visited": visited,
+        "whitelist_status": whitelistStatusValues.reverse[whitelistStatus],
+    };
+}
+
+enum Domain {
+    REDDIT_COM,
+    I_IMGUR_COM,
+    IMGUR_COM,
+    I_REDD_IT
+}
+
+final domainValues = EnumValues({
+    "reddit.com": Domain.REDDIT_COM,
+    "i.imgur.com": Domain.I_IMGUR_COM,
+    "imgur.com": Domain.IMGUR_COM,
+    "i.redd.it": Domain.I_REDD_IT
+});
+
+class MediaEmbed {
+    MediaEmbed();
+
+    factory MediaEmbed.fromJson(Map<String, dynamic> json) => MediaEmbed(
+    );
+
+    Map<String, dynamic> toJson() => {
+    };
+}
+
+enum WhitelistStatus {
+    ALL_ADS
+}
+
+final whitelistStatusValues = EnumValues({
+    "all_ads": WhitelistStatus.ALL_ADS
+});
+
+enum PostHint {
+    LINK,
+    IMAGE
+}
+
+final postHintValues = EnumValues({
+    "link": PostHint.LINK,
+    "image": PostHint.IMAGE
+});
+
+class Preview {
+    final bool enabled;
+    final List<Image> images;
+
+    Preview({
+        required this.enabled,
+        required this.images,
+    });
+
+    factory Preview.fromJson(Map<String, dynamic> json) => Preview(
+        enabled: json["enabled"],
+        images: List<Image>.from(json["images"].map((x) => Image.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "enabled": enabled,
+        "images": List<dynamic>.from(images.map((x) => x.toJson())),
+    };
+}
+
+class Image {
+    final String id;
+    final List<Source> resolutions;
+    final Source source;
+    final Variants variants;
+
+    Image({
+        required this.id,
+        required this.resolutions,
+        required this.source,
+        required this.variants,
+    });
+
+    factory Image.fromJson(Map<String, dynamic> json) => Image(
+        id: json["id"],
+        resolutions: List<Source>.from(json["resolutions"].map((x) => Source.fromJson(x))),
+        source: Source.fromJson(json["source"]),
+        variants: Variants.fromJson(json["variants"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "id": id,
+        "resolutions": List<dynamic>.from(resolutions.map((x) => x.toJson())),
+        "source": source.toJson(),
+        "variants": variants.toJson(),
+    };
+}
+
+class Source {
+    final int height;
+    final String url;
+    final int width;
+
+    Source({
+        required this.height,
+        required this.url,
+        required this.width,
+    });
+
+    factory Source.fromJson(Map<String, dynamic> json) => Source(
+        height: json["height"],
+        url: json["url"],
+        width: json["width"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "height": height,
+        "url": url,
+        "width": width,
+    };
+}
+
+class Variants {
+    final Gif? gif;
+    final Gif? mp4;
+
+    Variants({
+        this.gif,
+        this.mp4,
+    });
+
+    factory Variants.fromJson(Map<String, dynamic> json) => Variants(
+        gif: json["gif"] == null ? null : Gif.fromJson(json["gif"]),
+        mp4: json["mp4"] == null ? null : Gif.fromJson(json["mp4"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "gif": gif?.toJson(),
+        "mp4": mp4?.toJson(),
+    };
+}
+
+class Gif {
+    final List<Source> resolutions;
+    final Source source;
+
+    Gif({
+        required this.resolutions,
+        required this.source,
+    });
+
+    factory Gif.fromJson(Map<String, dynamic> json) => Gif(
+        resolutions: List<Source>.from(json["resolutions"].map((x) => Source.fromJson(x))),
+        source: Source.fromJson(json["source"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "resolutions": List<dynamic>.from(resolutions.map((x) => x.toJson())),
+        "source": source.toJson(),
+    };
+}
+
+enum Subreddit {
+    FUNNY
+}
+
+final subredditValues = EnumValues({
+    "funny": Subreddit.FUNNY
+});
+
+enum SubredditId {
+    T5_2_QH33
+}
+
+final subredditIdValues = EnumValues({
+    "t5_2qh33": SubredditId.T5_2_QH33
+});
+
+enum SubredditNamePrefixed {
+    R_FUNNY
+}
+
+final subredditNamePrefixedValues = EnumValues({
+    "r/funny": SubredditNamePrefixed.R_FUNNY
+});
+
+enum SubredditType {
+    PUBLIC
+}
+
+final subredditTypeValues = EnumValues({
+    "public": SubredditType.PUBLIC
+});
+
+enum Kind {
+    T3
+}
+
+final kindValues = EnumValues({
+    "t3": Kind.T3
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/dart/test/inputs/json/samples/us-senators.json/default/TopLevel.dart b/head/dart/test/inputs/json/samples/us-senators.json/default/TopLevel.dart
new file mode 100644
index 0000000..3e07dc2
--- /dev/null
+++ b/head/dart/test/inputs/json/samples/us-senators.json/default/TopLevel.dart
@@ -0,0 +1,389 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final Meta meta;
+    final List<Object> objects;
+
+    TopLevel({
+        required this.meta,
+        required this.objects,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        meta: Meta.fromJson(json["meta"]),
+        objects: List<Object>.from(json["objects"].map((x) => Object.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "meta": meta.toJson(),
+        "objects": List<dynamic>.from(objects.map((x) => x.toJson())),
+    };
+}
+
+class Meta {
+    final int limit;
+    final int offset;
+    final int totalCount;
+
+    Meta({
+        required this.limit,
+        required this.offset,
+        required this.totalCount,
+    });
+
+    factory Meta.fromJson(Map<String, dynamic> json) => Meta(
+        limit: json["limit"],
+        offset: json["offset"],
+        totalCount: json["total_count"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "limit": limit,
+        "offset": offset,
+        "total_count": totalCount,
+    };
+}
+
+class Object {
+    final Party? caucus;
+    final List<int> congressNumbers;
+    final bool current;
+    final String description;
+    final dynamic district;
+    final DateTime enddate;
+    final Extra extra;
+    final String? leadershipTitle;
+    final Party party;
+    final Person person;
+    final String phone;
+    final RoleType roleType;
+    final RoleTypeLabel roleTypeLabel;
+    final SenatorClass senatorClass;
+    final SenatorClassLabel senatorClassLabel;
+    final SenatorRank senatorRank;
+    final SenatorRankLabel senatorRankLabel;
+    final DateTime startdate;
+    final String state;
+    final Title title;
+    final RoleTypeLabel titleLong;
+    final String website;
+
+    Object({
+        required this.caucus,
+        required this.congressNumbers,
+        required this.current,
+        required this.description,
+        required this.district,
+        required this.enddate,
+        required this.extra,
+        required this.leadershipTitle,
+        required this.party,
+        required this.person,
+        required this.phone,
+        required this.roleType,
+        required this.roleTypeLabel,
+        required this.senatorClass,
+        required this.senatorClassLabel,
+        required this.senatorRank,
+        required this.senatorRankLabel,
+        required this.startdate,
+        required this.state,
+        required this.title,
+        required this.titleLong,
+        required this.website,
+    });
+
+    factory Object.fromJson(Map<String, dynamic> json) => Object(
+        caucus: partyValues.map[json["caucus"]],
+        congressNumbers: List<int>.from(json["congress_numbers"].map((x) => x)),
+        current: json["current"],
+        description: json["description"],
+        district: json["district"],
+        enddate: DateTime.parse(json["enddate"]),
+        extra: Extra.fromJson(json["extra"]),
+        leadershipTitle: json["leadership_title"],
+        party: partyValues.map[json["party"]]!,
+        person: Person.fromJson(json["person"]),
+        phone: json["phone"],
+        roleType: roleTypeValues.map[json["role_type"]]!,
+        roleTypeLabel: roleTypeLabelValues.map[json["role_type_label"]]!,
+        senatorClass: senatorClassValues.map[json["senator_class"]]!,
+        senatorClassLabel: senatorClassLabelValues.map[json["senator_class_label"]]!,
+        senatorRank: senatorRankValues.map[json["senator_rank"]]!,
+        senatorRankLabel: senatorRankLabelValues.map[json["senator_rank_label"]]!,
+        startdate: DateTime.parse(json["startdate"]),
+        state: json["state"],
+        title: titleValues.map[json["title"]]!,
+        titleLong: roleTypeLabelValues.map[json["title_long"]]!,
+        website: json["website"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "caucus": partyValues.reverse[caucus],
+        "congress_numbers": List<dynamic>.from(congressNumbers.map((x) => x)),
+        "current": current,
+        "description": description,
+        "district": district,
+        "enddate": "${enddate.year.toString().padLeft(4, '0')}-${enddate.month.toString().padLeft(2, '0')}-${enddate.day.toString().padLeft(2, '0')}",
+        "extra": extra.toJson(),
+        "leadership_title": leadershipTitle,
+        "party": partyValues.reverse[party],
+        "person": person.toJson(),
+        "phone": phone,
+        "role_type": roleTypeValues.reverse[roleType],
+        "role_type_label": roleTypeLabelValues.reverse[roleTypeLabel],
+        "senator_class": senatorClassValues.reverse[senatorClass],
+        "senator_class_label": senatorClassLabelValues.reverse[senatorClassLabel],
+        "senator_rank": senatorRankValues.reverse[senatorRank],
+        "senator_rank_label": senatorRankLabelValues.reverse[senatorRankLabel],
+        "startdate": "${startdate.year.toString().padLeft(4, '0')}-${startdate.month.toString().padLeft(2, '0')}-${startdate.day.toString().padLeft(2, '0')}",
+        "state": state,
+        "title": titleValues.reverse[title],
+        "title_long": roleTypeLabelValues.reverse[titleLong],
+        "website": website,
+    };
+}
+
+enum Party {
+    DEMOCRAT,
+    REPUBLICAN,
+    INDEPENDENT
+}
+
+final partyValues = EnumValues({
+    "Democrat": Party.DEMOCRAT,
+    "Republican": Party.REPUBLICAN,
+    "Independent": Party.INDEPENDENT
+});
+
+class Extra {
+    final String address;
+    final String contactForm;
+    final String? fax;
+    final String office;
+    final String? rssUrl;
+
+    Extra({
+        required this.address,
+        required this.contactForm,
+        this.fax,
+        required this.office,
+        this.rssUrl,
+    });
+
+    factory Extra.fromJson(Map<String, dynamic> json) => Extra(
+        address: json["address"],
+        contactForm: json["contact_form"],
+        fax: json["fax"],
+        office: json["office"],
+        rssUrl: json["rss_url"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "address": address,
+        "contact_form": contactForm,
+        "fax": fax,
+        "office": office,
+        "rss_url": rssUrl,
+    };
+}
+
+class Person {
+    final String bioguideid;
+    final DateTime birthday;
+    final int cspanid;
+    final String firstname;
+    final Gender gender;
+    final GenderLabel genderLabel;
+    final String lastname;
+    final String link;
+    final String middlename;
+    final String name;
+    final Namemod namemod;
+    final String nickname;
+    final String osid;
+    final String pvsid;
+    final String sortname;
+    final String? twitterid;
+    final String? youtubeid;
+
+    Person({
+        required this.bioguideid,
+        required this.birthday,
+        required this.cspanid,
+        required this.firstname,
+        required this.gender,
+        required this.genderLabel,
+        required this.lastname,
+        required this.link,
+        required this.middlename,
+        required this.name,
+        required this.namemod,
+        required this.nickname,
+        required this.osid,
+        required this.pvsid,
+        required this.sortname,
+        required this.twitterid,
+        required this.youtubeid,
+    });
+
+    factory Person.fromJson(Map<String, dynamic> json) => Person(
+        bioguideid: json["bioguideid"],
+        birthday: DateTime.parse(json["birthday"]),
+        cspanid: json["cspanid"],
+        firstname: json["firstname"],
+        gender: genderValues.map[json["gender"]]!,
+        genderLabel: genderLabelValues.map[json["gender_label"]]!,
+        lastname: json["lastname"],
+        link: json["link"],
+        middlename: json["middlename"],
+        name: json["name"],
+        namemod: namemodValues.map[json["namemod"]]!,
+        nickname: json["nickname"],
+        osid: json["osid"],
+        pvsid: json["pvsid"],
+        sortname: json["sortname"],
+        twitterid: json["twitterid"],
+        youtubeid: json["youtubeid"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "bioguideid": bioguideid,
+        "birthday": "${birthday.year.toString().padLeft(4, '0')}-${birthday.month.toString().padLeft(2, '0')}-${birthday.day.toString().padLeft(2, '0')}",
+        "cspanid": cspanid,
+        "firstname": firstname,
+        "gender": genderValues.reverse[gender],
+        "gender_label": genderLabelValues.reverse[genderLabel],
+        "lastname": lastname,
+        "link": link,
+        "middlename": middlename,
+        "name": name,
+        "namemod": namemodValues.reverse[namemod],
+        "nickname": nickname,
+        "osid": osid,
+        "pvsid": pvsid,
+        "sortname": sortname,
+        "twitterid": twitterid,
+        "youtubeid": youtubeid,
+    };
+}
+
+enum Gender {
+    FEMALE,
+    MALE
+}
+
+final genderValues = EnumValues({
+    "female": Gender.FEMALE,
+    "male": Gender.MALE
+});
+
+enum GenderLabel {
+    FEMALE,
+    MALE
+}
+
+final genderLabelValues = EnumValues({
+    "Female": GenderLabel.FEMALE,
+    "Male": GenderLabel.MALE
+});
+
+enum Namemod {
+    EMPTY,
+    JR,
+    III
+}
+
+final namemodValues = EnumValues({
+    "": Namemod.EMPTY,
+    "Jr.": Namemod.JR,
+    "III": Namemod.III
+});
+
+enum RoleType {
+    SENATOR
+}
+
+final roleTypeValues = EnumValues({
+    "senator": RoleType.SENATOR
+});
+
+enum RoleTypeLabel {
+    SENATOR
+}
+
+final roleTypeLabelValues = EnumValues({
+    "Senator": RoleTypeLabel.SENATOR
+});
+
+enum SenatorClass {
+    CLASS1,
+    CLASS2,
+    CLASS3
+}
+
+final senatorClassValues = EnumValues({
+    "class1": SenatorClass.CLASS1,
+    "class2": SenatorClass.CLASS2,
+    "class3": SenatorClass.CLASS3
+});
+
+enum SenatorClassLabel {
+    CLASS_1,
+    CLASS_2,
+    CLASS_3
+}
+
+final senatorClassLabelValues = EnumValues({
+    "Class 1": SenatorClassLabel.CLASS_1,
+    "Class 2": SenatorClassLabel.CLASS_2,
+    "Class 3": SenatorClassLabel.CLASS_3
+});
+
+enum SenatorRank {
+    JUNIOR,
+    SENIOR
+}
+
+final senatorRankValues = EnumValues({
+    "junior": SenatorRank.JUNIOR,
+    "senior": SenatorRank.SENIOR
+});
+
+enum SenatorRankLabel {
+    JUNIOR,
+    SENIOR
+}
+
+final senatorRankLabelValues = EnumValues({
+    "Junior": SenatorRankLabel.JUNIOR,
+    "Senior": SenatorRankLabel.SENIOR
+});
+
+enum Title {
+    SEN
+}
+
+final titleValues = EnumValues({
+    "Sen.": Title.SEN
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/base/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex
index 56e0770..e1f54a7 100644
--- a/base/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex
@@ -233,7 +233,7 @@ defmodule OtherName do
   def from_map(m) do
     %OtherName{
       name: m["name"],
-      note: m["note"],
+      note: Map.fetch!(m, "note"),
     }
   end
 
@@ -411,7 +411,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: m["name"],
       other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
-      superseded_by: m["superseded_by"],
+      superseded_by: Map.fetch!(m, "superseded_by"),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex
index a2da62e..3c05309 100644
--- a/base/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex
@@ -242,7 +242,7 @@ defmodule OtherName do
   def from_map(m) do
     %OtherName{
       name: m["name"],
-      note: m["note"],
+      note: Map.fetch!(m, "note"),
     }
   end
 
@@ -422,7 +422,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: m["name"],
       other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
-      superseded_by: m["superseded_by"],
+      superseded_by: Map.fetch!(m, "superseded_by"),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex
index 2ee46f9..4acf242 100644
--- a/base/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex
@@ -317,10 +317,10 @@ defmodule Person do
       namemod: Namemod.decode(m["namemod"]),
       nickname: m["nickname"],
       osid: m["osid"],
-      pvsid: m["pvsid"],
+      pvsid: Map.fetch!(m, "pvsid"),
       sortname: m["sortname"],
-      twitterid: m["twitterid"],
-      youtubeid: m["youtubeid"],
+      twitterid: Map.fetch!(m, "twitterid"),
+      youtubeid: Map.fetch!(m, "youtubeid"),
     }
   end
 
@@ -536,7 +536,7 @@ defmodule Object do
       enddate: m["enddate"],
       extra: Extra.from_map(m["extra"]),
       id: m["id"],
-      leadership_title: m["leadership_title"],
+      leadership_title: Map.fetch!(m, "leadership_title"),
       party: Party.decode(m["party"]),
       person: Person.from_map(m["person"]),
       phone: m["phone"],
diff --git a/base/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex
index ecb3f71..f369b61 100644
--- a/base/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex
@@ -645,8 +645,8 @@ defmodule ChildData do
       approved_by: m["approved_by"],
       archived: m["archived"],
       author: m["author"],
-      author_flair_css_class: m["author_flair_css_class"],
-      author_flair_text: m["author_flair_text"],
+      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
+      author_flair_text: Map.fetch!(m, "author_flair_text"),
       banned_at_utc: m["banned_at_utc"],
       banned_by: m["banned_by"],
       brand_safe: m["brand_safe"],
@@ -656,7 +656,7 @@ defmodule ChildData do
       contest_mode: m["contest_mode"],
       created: m["created"],
       created_utc: m["created_utc"],
-      distinguished: m["distinguished"],
+      distinguished: Map.fetch!(m, "distinguished"),
       domain: Domain.decode(m["domain"]),
       downs: m["downs"],
       edited: m["edited"],
@@ -667,8 +667,8 @@ defmodule ChildData do
       is_self: m["is_self"],
       is_video: m["is_video"],
       likes: m["likes"],
-      link_flair_css_class: m["link_flair_css_class"],
-      link_flair_text: m["link_flair_text"],
+      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
+      link_flair_text: Map.fetch!(m, "link_flair_text"),
       locked: m["locked"],
       media: m["media"] && Media.from_map(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
@@ -688,7 +688,7 @@ defmodule ChildData do
       secure_media: m["secure_media"] && Media.from_map(m["secure_media"]),
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: m["selftext"],
-      selftext_html: m["selftext_html"],
+      selftext_html: Map.fetch!(m, "selftext_html"),
       spoiler: m["spoiler"],
       stickied: m["stickied"],
       subreddit: Subreddit.decode(m["subreddit"]),
@@ -697,8 +697,8 @@ defmodule ChildData do
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
       suggested_sort: m["suggested_sort"],
       thumbnail: m["thumbnail"],
-      thumbnail_height: m["thumbnail_height"],
-      thumbnail_width: m["thumbnail_width"],
+      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
+      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
       title: m["title"],
       ups: m["ups"],
       url: m["url"],
diff --git a/base/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex
index 3a0f4ef..bcc51d3 100644
--- a/base/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex
@@ -630,7 +630,7 @@ defmodule ChildData do
       distinguished: Distinguished.decode(m["distinguished"]),
       domain: Domain.decode(m["domain"]),
       downs: m["downs"],
-      edited: m["edited"],
+      edited: Map.fetch!(m, "edited"),
       gilded: m["gilded"],
       hidden: m["hidden"],
       hide_score: m["hide_score"],
@@ -659,17 +659,17 @@ defmodule ChildData do
       secure_media: m["secure_media"],
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: m["selftext"],
-      selftext_html: m["selftext_html"],
+      selftext_html: Map.fetch!(m, "selftext_html"),
       spoiler: m["spoiler"],
       stickied: m["stickied"],
       subreddit: Subreddit.decode(m["subreddit"]),
       subreddit_id: SubredditID.decode(m["subreddit_id"]),
       subreddit_name_prefixed: SubredditNamePrefixed.decode(m["subreddit_name_prefixed"]),
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
-      suggested_sort: m["suggested_sort"],
+      suggested_sort: Map.fetch!(m, "suggested_sort"),
       thumbnail: m["thumbnail"],
-      thumbnail_height: m["thumbnail_height"],
-      thumbnail_width: m["thumbnail_width"],
+      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
+      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
       title: m["title"],
       ups: m["ups"],
       url: m["url"],
diff --git a/base/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex
index 95c591a..d6c3d4c 100644
--- a/base/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex
@@ -318,8 +318,8 @@ defmodule Person do
       osid: m["osid"],
       pvsid: m["pvsid"],
       sortname: m["sortname"],
-      twitterid: m["twitterid"],
-      youtubeid: m["youtubeid"],
+      twitterid: Map.fetch!(m, "twitterid"),
+      youtubeid: Map.fetch!(m, "youtubeid"),
     }
   end
 
@@ -720,7 +720,7 @@ defmodule Object do
       enddate: m["enddate"],
       extra: Extra.from_map(m["extra"]),
       id: m["id"],
-      leadership_title: m["leadership_title"],
+      leadership_title: Map.fetch!(m, "leadership_title"),
       party: Party.decode(m["party"]),
       person: Person.from_map(m["person"]),
       phone: m["phone"],
diff --git a/base/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex
index baa9de1..3537d09 100644
--- a/base/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex
@@ -263,15 +263,15 @@ defmodule Properties do
       cdi: m["cdi"],
       code: m["code"],
       detail: m["detail"],
-      dmin: m["dmin"],
+      dmin: Map.fetch!(m, "dmin"),
       felt: m["felt"],
-      gap: m["gap"],
+      gap: Map.fetch!(m, "gap"),
       ids: m["ids"],
       mag: m["mag"],
       mag_type: MagType.decode(m["magType"]),
       mmi: m["mmi"],
       net: m["net"],
-      nst: m["nst"],
+      nst: Map.fetch!(m, "nst"),
       place: m["place"],
       rms: m["rms"],
       sig: m["sig"],
diff --git a/base/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex
index be65093..2196bb0 100644
--- a/base/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex
@@ -22,7 +22,7 @@ defmodule TopLevelElement do
 
   def from_map(m) do
     %TopLevelElement{
-      birth_date: m["BirthDate"],
+      birth_date: Map.fetch!(m, "BirthDate"),
       birth_date_is_protected: m["BirthDateIsProtected"],
       gender_type_id: m["GenderTypeID"],
       notes: m["Notes"],
diff --git a/base/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex
index b60b7c7..0a67ae7 100644
--- a/base/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex
@@ -268,35 +268,35 @@ defmodule Result do
 
   def from_map(m) do
     %Result{
-      cost_absolute: m["cost_absolute"],
-      cost_max: m["cost_max"],
-      cost_min: m["cost_min"],
+      cost_absolute: Map.fetch!(m, "cost_absolute"),
+      cost_max: Map.fetch!(m, "cost_max"),
+      cost_min: Map.fetch!(m, "cost_min"),
       created_at: m["created_at"],
       custom_incomes: Enum.map(m["customIncomes"], &CustomIncome.from_map/1),
       direct_rep_costs_max: m["direct_rep_costs_max"],
       direct_rep_costs_min: m["direct_rep_costs_min"],
       end_date: m["end_date"],
       eur_sources_grants: m["eur_sources_grants"],
-      eur_sources_grants_src: m["eur_sources_grants_src"],
+      eur_sources_grants_src: Map.fetch!(m, "eur_sources_grants_src"),
       eur_sources_procurement: m["eur_sources_procurement"],
-      eur_sources_procurement_src: m["eur_sources_procurement_src"],
+      eur_sources_procurement_src: Map.fetch!(m, "eur_sources_procurement_src"),
       id: m["id"],
       new_organisation: m["new_organisation"],
-      no_clients: m["no_clients"],
-      other_financial_information: m["other_financial_information"],
-      other_sources_contributions: m["other_sources_contributions"],
-      other_sources_donation: m["other_sources_donation"],
-      other_sources_total: m["other_sources_total"],
-      public_financing_infranational: m["public_financing_infranational"],
-      public_financing_national: m["public_financing_national"],
-      public_financing_total: m["public_financing_total"],
+      no_clients: Map.fetch!(m, "no_clients"),
+      other_financial_information: Map.fetch!(m, "other_financial_information"),
+      other_sources_contributions: Map.fetch!(m, "other_sources_contributions"),
+      other_sources_donation: Map.fetch!(m, "other_sources_donation"),
+      other_sources_total: Map.fetch!(m, "other_sources_total"),
+      public_financing_infranational: Map.fetch!(m, "public_financing_infranational"),
+      public_financing_national: Map.fetch!(m, "public_financing_national"),
+      public_financing_total: Map.fetch!(m, "public_financing_total"),
       representative: m["representative"],
       start_date: m["start_date"],
       status: Status.decode(m["status"]),
-      total_budget: m["total_budget"],
-      turnover_absolute: m["turnover_absolute"],
-      turnover_max: m["turnover_max"],
-      turnover_min: m["turnover_min"],
+      total_budget: Map.fetch!(m, "total_budget"),
+      turnover_absolute: Map.fetch!(m, "turnover_absolute"),
+      turnover_max: Map.fetch!(m, "turnover_max"),
+      turnover_min: Map.fetch!(m, "turnover_min"),
       type: ResultType.decode(m["type"]),
       updated_at: m["updated_at"],
       uri: m["uri"],
diff --git a/base/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex
index 0db0bcc..6b5046e 100644
--- a/base/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex
@@ -392,7 +392,7 @@ defmodule FeatureProperties do
       latitude: m["latitude"],
       local_govt: m["local_govt"],
       longitude: m["longitude"],
-      no: m["no"],
+      no: Map.fetch!(m, "no"),
       phone: m["phone"],
       postcode: m["postcode"],
       psa: m["psa"],
diff --git a/base/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex
index 5991113..d73208e 100644
--- a/base/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex
@@ -652,8 +652,8 @@ defmodule ChildData do
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
       suggested_sort: m["suggested_sort"],
       thumbnail: m["thumbnail"],
-      thumbnail_height: m["thumbnail_height"],
-      thumbnail_width: m["thumbnail_width"],
+      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
+      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
       title: m["title"],
       ups: m["ups"],
       url: m["url"],
diff --git a/base/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex
index 6cabfc4..a97a9f1 100644
--- a/base/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex
@@ -136,7 +136,7 @@ defmodule OtherName do
   def from_map(m) do
     %OtherName{
       name: m["name"],
-      note: m["note"],
+      note: Map.fetch!(m, "note"),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex
index 24d4f91..1af1cf4 100644
--- a/base/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex
@@ -368,7 +368,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: m["name"],
       other_names: m["other_names"],
-      superseded_by: m["superseded_by"],
+      superseded_by: Map.fetch!(m, "superseded_by"),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex
index 3ff80b5..d63c9e2 100644
--- a/base/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex
@@ -511,8 +511,8 @@ defmodule ChildData do
       approved_by: m["approved_by"],
       archived: m["archived"],
       author: m["author"],
-      author_flair_css_class: m["author_flair_css_class"],
-      author_flair_text: m["author_flair_text"],
+      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
+      author_flair_text: Map.fetch!(m, "author_flair_text"),
       banned_at_utc: m["banned_at_utc"],
       banned_by: m["banned_by"],
       brand_safe: m["brand_safe"],
@@ -533,8 +533,8 @@ defmodule ChildData do
       is_self: m["is_self"],
       is_video: m["is_video"],
       likes: m["likes"],
-      link_flair_css_class: m["link_flair_css_class"],
-      link_flair_text: m["link_flair_text"],
+      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
+      link_flair_text: Map.fetch!(m, "link_flair_text"),
       locked: m["locked"],
       media: m["media"] && Media.from_map(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
@@ -554,17 +554,17 @@ defmodule ChildData do
       secure_media: m["secure_media"] && Media.from_map(m["secure_media"]),
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: m["selftext"],
-      selftext_html: m["selftext_html"],
+      selftext_html: Map.fetch!(m, "selftext_html"),
       spoiler: m["spoiler"],
       stickied: m["stickied"],
       subreddit: m["subreddit"],
       subreddit_id: m["subreddit_id"],
       subreddit_name_prefixed: m["subreddit_name_prefixed"],
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
-      suggested_sort: m["suggested_sort"],
+      suggested_sort: Map.fetch!(m, "suggested_sort"),
       thumbnail: m["thumbnail"],
-      thumbnail_height: m["thumbnail_height"],
-      thumbnail_width: m["thumbnail_width"],
+      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
+      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
       title: m["title"],
       ups: m["ups"],
       url: m["url"],
diff --git a/base/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex
index 36b96cc..cbbfd24 100644
--- a/base/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex
@@ -147,14 +147,14 @@ defmodule Result do
 
   def from_map(m) do
     %Result{
-      acronym: m["acronym"],
+      acronym: Map.fetch!(m, "acronym"),
       activity_consult_committees: m["activity_consult_committees"],
       activity_eu_legislative: m["activity_eu_legislative"],
       activity_expert_groups: m["activity_expert_groups"],
       activity_high_level_groups: m["activity_high_level_groups"],
       activity_industry_forums: m["activity_industry_forums"],
       activity_inter_groups: m["activity_inter_groups"],
-      activity_other: m["activity_other"],
+      activity_other: Map.fetch!(m, "activity_other"),
       activity_relevant_comm: m["activity_relevant_comm"],
       be_office_country: m["be_office_country"],
       be_office_lat: m["be_office_lat"],
@@ -171,11 +171,11 @@ defmodule Result do
       goals: m["goals"],
       head: m["head"],
       head_office_country: m["head_office_country"],
-      head_office_lat: m["head_office_lat"],
-      head_office_lon: m["head_office_lon"],
+      head_office_lat: Map.fetch!(m, "head_office_lat"),
+      head_office_lon: Map.fetch!(m, "head_office_lon"),
       head_office_phone: m["head_office_phone"],
-      head_office_post_code: m["head_office_post_code"],
-      head_office_postbox: m["head_office_postbox"],
+      head_office_post_code: Map.fetch!(m, "head_office_post_code"),
+      head_office_postbox: Map.fetch!(m, "head_office_postbox"),
       head_office_street: m["head_office_street"],
       head_office_town: m["head_office_town"],
       id: m["id"],
@@ -187,16 +187,16 @@ defmodule Result do
       main_category: m["main_category"],
       main_category_title: m["main_category_title"],
       members: m["members"],
-      members_100: m["members_100"],
-      members_25: m["members_25"],
-      members_50: m["members_50"],
-      members_75: m["members_75"],
+      members_100: Map.fetch!(m, "members_100"),
+      members_25: Map.fetch!(m, "members_25"),
+      members_50: Map.fetch!(m, "members_50"),
+      members_75: Map.fetch!(m, "members_75"),
       members_fte: m["members_fte"],
       name: m["name"],
       native_name: m["native_name"],
-      networking: m["networking"],
-      number_of_natural_persons: m["number_of_natural_persons"],
-      other_code_of_conduct: m["other_code_of_conduct"],
+      networking: Map.fetch!(m, "networking"),
+      number_of_natural_persons: Map.fetch!(m, "number_of_natural_persons"),
+      other_code_of_conduct: Map.fetch!(m, "other_code_of_conduct"),
       registration_date: m["registration_date"],
       status: Status.decode(m["status"]),
       structure_members: m["structure_members"],
@@ -204,7 +204,7 @@ defmodule Result do
       sub_category_title: m["sub_category_title"],
       updated_at: m["updated_at"],
       uri: m["uri"],
-      web_site_url: m["web_site_url"],
+      web_site_url: Map.fetch!(m, "web_site_url"),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex
index 5eeef7c..37996bb 100644
--- a/base/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex
@@ -169,7 +169,7 @@ defmodule TopLevelElement do
       comments_url: m["comments_url"],
       commits_url: m["commits_url"],
       created_at: m["created_at"],
-      description: m["description"],
+      description: Map.fetch!(m, "description"),
       files: m["files"]
       |> Map.new(fn {key, value} -> {key, FileValue.from_map(value)} end),
       forks_url: m["forks_url"],
diff --git a/base/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex
index 323580f..e6c95a3 100644
--- a/base/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex
@@ -54,7 +54,7 @@ defmodule Result do
       id: m["id"],
       items: m["items"],
       name: m["name"],
-      parent: m["parent"],
+      parent: Map.fetch!(m, "parent"),
       updated_at: m["updated_at"],
       uri: m["uri"],
     }
diff --git a/base/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex
index 292c413..ba32c9c 100644
--- a/base/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex
@@ -499,8 +499,8 @@ defmodule ChildData do
       approved_by: m["approved_by"],
       archived: m["archived"],
       author: m["author"],
-      author_flair_css_class: m["author_flair_css_class"],
-      author_flair_text: m["author_flair_text"],
+      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
+      author_flair_text: Map.fetch!(m, "author_flair_text"),
       banned_at_utc: m["banned_at_utc"],
       banned_by: m["banned_by"],
       brand_safe: m["brand_safe"],
@@ -542,7 +542,7 @@ defmodule ChildData do
       secure_media: m["secure_media"],
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: m["selftext"],
-      selftext_html: m["selftext_html"],
+      selftext_html: Map.fetch!(m, "selftext_html"),
       spoiler: m["spoiler"],
       stickied: m["stickied"],
       subreddit: Subreddit.decode(m["subreddit"]),
@@ -551,8 +551,8 @@ defmodule ChildData do
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
       suggested_sort: SuggestedSort.decode(m["suggested_sort"]),
       thumbnail: m["thumbnail"],
-      thumbnail_height: m["thumbnail_height"],
-      thumbnail_width: m["thumbnail_width"],
+      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
+      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
       title: m["title"],
       ups: m["ups"],
       url: m["url"],
diff --git a/base/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex
index 3690a16..f2778ed 100644
--- a/base/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex
@@ -326,7 +326,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: m["name"],
       other_names: m["other_names"],
-      superseded_by: m["superseded_by"],
+      superseded_by: Map.fetch!(m, "superseded_by"),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex
index a9040b4..fab0231 100644
--- a/base/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex
@@ -152,7 +152,7 @@ defmodule Result do
       id: m["id"],
       last_name: m["last_name"],
       name: m["name"],
-      position: m["position"],
+      position: Map.fetch!(m, "position"),
       status: Status.decode(m["status"]),
       title: m["title"] && Title.decode(m["title"]),
       updated_at: m["updated_at"],
diff --git a/base/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex
index a2da62e..3c05309 100644
--- a/base/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex
@@ -242,7 +242,7 @@ defmodule OtherName do
   def from_map(m) do
     %OtherName{
       name: m["name"],
-      note: m["note"],
+      note: Map.fetch!(m, "note"),
     }
   end
 
@@ -422,7 +422,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: m["name"],
       other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
-      superseded_by: m["superseded_by"],
+      superseded_by: Map.fetch!(m, "superseded_by"),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex
index 8c54ca1..fa8f910 100644
--- a/base/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex
@@ -354,8 +354,8 @@ defmodule ChildData do
       is_self: m["is_self"],
       is_video: m["is_video"],
       likes: m["likes"],
-      link_flair_css_class: m["link_flair_css_class"],
-      link_flair_text: m["link_flair_text"],
+      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
+      link_flair_text: Map.fetch!(m, "link_flair_text"),
       locked: m["locked"],
       media: m["media"],
       media_embed: MediaEmbed.from_map(m["media_embed"]),
diff --git a/base/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex
index bf15b60..3183830 100644
--- a/base/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex
@@ -577,16 +577,16 @@ defmodule FeatureProperties do
       add_improv: m["add_improv"] && AddImprov.decode(m["add_improv"]),
       area: m["area_"],
       asset_numb: m["asset_numb"],
-      comments: m["comments"],
+      comments: Map.fetch!(m, "comments"),
       condition: m["condition"],
-      constructi: m["constructi"],
+      constructi: Map.fetch!(m, "constructi"),
       createdate: m["createdate"],
       createuser: m["createuser"],
       disposal_d: m["disposal_d"],
       documents: m["documents"],
-      drawing_nu: m["drawing_nu"],
-      file_numbe: m["file_numbe"],
-      folder_num: m["folder_num"],
+      drawing_nu: Map.fetch!(m, "drawing_nu"),
+      file_numbe: Map.fetch!(m, "file_numbe"),
+      folder_num: Map.fetch!(m, "folder_num"),
       funding_ba: m["funding_ba"] && FundingBa.decode(m["funding_ba"]),
       historic_c: m["historic_c"],
       inspection: m["inspection"],
@@ -597,11 +597,11 @@ defmodule FeatureProperties do
       mi_prinx: m["mi_prinx"],
       mi_symbolo: MiSymbolo.decode(m["mi_symbolo"]),
       number_lan: m["number_lan"],
-      owner: m["owner"],
+      owner: Map.fetch!(m, "owner"),
       positional: m["positional"] && LevelAccu.decode(m["positional"]),
-      project_nu: m["project_nu"],
+      project_nu: Map.fetch!(m, "project_nu"),
       rec_id: m["rec_id"],
-      record_cre: m["record_cre"],
+      record_cre: Map.fetch!(m, "record_cre"),
       shape_area: m["shape_area"],
       shape_leng: m["shape_leng"],
       status: Status.decode(m["status"]),
diff --git a/base/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex
index dc14f1b..5e5b461 100644
--- a/base/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex
@@ -690,7 +690,7 @@ defmodule ChildData do
       archived: m["archived"],
       author: m["author"],
       author_flair_css_class: m["author_flair_css_class"],
-      author_flair_text: m["author_flair_text"],
+      author_flair_text: Map.fetch!(m, "author_flair_text"),
       banned_at_utc: m["banned_at_utc"],
       banned_by: m["banned_by"],
       brand_safe: m["brand_safe"],
@@ -700,7 +700,7 @@ defmodule ChildData do
       contest_mode: m["contest_mode"],
       created: m["created"],
       created_utc: m["created_utc"],
-      distinguished: m["distinguished"],
+      distinguished: Map.fetch!(m, "distinguished"),
       domain: Domain.decode(m["domain"]),
       downs: m["downs"],
       edited: m["edited"],
diff --git a/base/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex
index 0684ee9..4238306 100644
--- a/base/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex
@@ -49,7 +49,7 @@ defmodule Result do
 
   def from_map(m) do
     %Result{
-      acronym: m["acronym"],
+      acronym: Map.fetch!(m, "acronym"),
       created_at: m["created_at"],
       id: m["id"],
       name: m["name"],
diff --git a/base/elixir/test/inputs/json/misc/ed095.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/ed095.json/default/QuickType.ex
index 02c4183..10f0eee 100644
--- a/base/elixir/test/inputs/json/misc/ed095.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/ed095.json/default/QuickType.ex
@@ -6,8 +6,12 @@
 # Encode into a JSON string: TopLevel.to_json(struct)
 
 defmodule TopLevel do
+  def decode_value(value) when is_map(value), do: value
+
   def from_json(json) do
-    Jason.decode!(json)
+    json
+    |> Jason.decode!()
+    |> decode_value()
   end
 
   def to_json(data) do
diff --git a/base/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex
index 49d9d07..3c14697 100644
--- a/base/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex
@@ -309,8 +309,8 @@ defmodule ChildData do
       is_self: m["is_self"],
       is_video: m["is_video"],
       likes: m["likes"],
-      link_flair_css_class: m["link_flair_css_class"],
-      link_flair_text: m["link_flair_text"],
+      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
+      link_flair_text: Map.fetch!(m, "link_flair_text"),
       locked: m["locked"],
       media: m["media"],
       media_embed: MediaEmbed.from_map(m["media_embed"]),
diff --git a/base/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex
index df2b41f..6f04836 100644
--- a/base/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex
@@ -17,8 +17,8 @@ defmodule Invoice do
 
   def from_map(m) do
     %Invoice{
-      created_at: m["createdAt"],
-      due_date: m["dueDate"],
+      created_at: Map.fetch!(m, "createdAt"),
+      due_date: Map.fetch!(m, "dueDate"),
       name: m["name"],
     }
   end
diff --git a/base/elixir/test/inputs/json/priority/bug855-short.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/bug855-short.json/default/QuickType.ex
index d273895..088c1e0 100644
--- a/base/elixir/test/inputs/json/priority/bug855-short.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/bug855-short.json/default/QuickType.ex
@@ -51,8 +51,12 @@ defmodule TopLevelValue do
 end
 
 defmodule TopLevel do
+  def decode_value(value) when is_map(value), do: value
+
   def from_json(json) do
-    Jason.decode!(json)
+    json
+    |> Jason.decode!()
+    |> decode_value()
   end
 
   def to_json(data) do
diff --git a/base/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex
index 7376ce5..a35ff78 100644
--- a/base/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex
@@ -875,7 +875,7 @@ defmodule Pl do
       s_free_throws_attempted: m["sFreeThrowsAttempted"],
       s_free_throws_made: m["sFreeThrowsMade"],
       s_free_throws_percentage: m["sFreeThrowsPercentage"],
-      s_minutes: m["sMinutes"],
+      s_minutes: Map.fetch!(m, "sMinutes"),
       s_plus_minus_points: m["sPlusMinusPoints"],
       s_points: m["sPoints"],
       s_points_fast_break: m["sPointsFastBreak"],
diff --git a/base/elixir/test/inputs/json/priority/no-classes.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/no-classes.json/default/QuickType.ex
index 02c4183..450c7e6 100644
--- a/base/elixir/test/inputs/json/priority/no-classes.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/no-classes.json/default/QuickType.ex
@@ -7,7 +7,8 @@
 
 defmodule TopLevel do
   def from_json(json) do
-    Jason.decode!(json)
+    json
+    |> Jason.decode!()
   end
 
   def to_json(data) do
diff --git a/base/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex
index 15cdbe1..69b48eb 100644
--- a/base/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex
@@ -389,7 +389,7 @@ defmodule Milestone do
       created_at: m["created_at"],
       creator: User.from_map(m["creator"]),
       description: m["description"],
-      due_on: m["due_on"],
+      due_on: Map.fetch!(m, "due_on"),
       html_url: m["html_url"],
       id: m["id"],
       labels_url: m["labels_url"],
@@ -511,7 +511,7 @@ defmodule Issue do
       assignee: m["assignee"],
       assignees: m["assignees"],
       body: m["body"],
-      closed_at: m["closed_at"],
+      closed_at: Map.fetch!(m, "closed_at"),
       comments: m["comments"],
       comments_url: m["comments_url"],
       created_at: m["created_at"],
diff --git a/base/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex
index 77eee54..887f780 100644
--- a/base/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex
@@ -50,7 +50,7 @@ defmodule PersonElement do
 
   def from_map(m) do
     %PersonElement{
-      int_or_string: m["intOrString"],
+      int_or_string: Map.fetch!(m, "intOrString"),
       name: m["name"],
       optional_value: m["optionalValue"],
     }
diff --git a/base/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex
index 9d068c0..de89e2b 100644
--- a/base/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex
@@ -60,7 +60,7 @@ defmodule Item do
       address: m["address"] && Address.from_map(m["address"]),
       created_at: m["created_at"],
       name: m["name"],
-      sex: m["sex"],
+      sex: Map.fetch!(m, "sex"),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex
index f4b2050..826209a 100644
--- a/base/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex
@@ -620,8 +620,8 @@ defmodule ChildData do
       approved_by: m["approved_by"],
       archived: m["archived"],
       author: m["author"],
-      author_flair_css_class: m["author_flair_css_class"],
-      author_flair_text: m["author_flair_text"],
+      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
+      author_flair_text: Map.fetch!(m, "author_flair_text"),
       banned_at_utc: m["banned_at_utc"],
       banned_by: m["banned_by"],
       brand_safe: m["brand_safe"],
@@ -631,7 +631,7 @@ defmodule ChildData do
       contest_mode: m["contest_mode"],
       created: m["created"],
       created_utc: m["created_utc"],
-      distinguished: m["distinguished"],
+      distinguished: Map.fetch!(m, "distinguished"),
       domain: Domain.decode(m["domain"]),
       downs: m["downs"],
       edited: m["edited"],
@@ -642,8 +642,8 @@ defmodule ChildData do
       is_self: m["is_self"],
       is_video: m["is_video"],
       likes: m["likes"],
-      link_flair_css_class: m["link_flair_css_class"],
-      link_flair_text: m["link_flair_text"],
+      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
+      link_flair_text: Map.fetch!(m, "link_flair_text"),
       locked: m["locked"],
       media: m["media"],
       media_embed: MediaEmbed.from_map(m["media_embed"]),
diff --git a/base/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex
index e53e56e..b93ebc2 100644
--- a/base/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex
@@ -316,8 +316,8 @@ defmodule Person do
       osid: m["osid"],
       pvsid: m["pvsid"],
       sortname: m["sortname"],
-      twitterid: m["twitterid"],
-      youtubeid: m["youtubeid"],
+      twitterid: Map.fetch!(m, "twitterid"),
+      youtubeid: Map.fetch!(m, "youtubeid"),
     }
   end
 
@@ -715,7 +715,7 @@ defmodule Object do
       district: m["district"],
       enddate: m["enddate"],
       extra: Extra.from_map(m["extra"]),
-      leadership_title: m["leadership_title"],
+      leadership_title: Map.fetch!(m, "leadership_title"),
       party: Party.decode(m["party"]),
       person: Person.from_map(m["person"]),
       phone: m["phone"],
diff --git a/base/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex
index 64994e1..bf2cb0e 100644
--- a/base/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex
@@ -17,7 +17,7 @@ defmodule User do
   def from_map(m) do
     %User{
       login: m["login"],
-      real_name: m["realName"],
+      real_name: Map.fetch!(m, "realName"),
     }
   end
 
diff --git a/base/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex
index 4157aad..45d539d 100644
--- a/base/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex
@@ -172,7 +172,7 @@ defmodule User do
   def from_map(m) do
     %User{
       login: m["login"],
-      name: m["name"],
+      name: Map.fetch!(m, "name"),
       repository: m["repository"] && Repository.from_map(m["repository"]),
     }
   end
diff --git a/base/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex
index ee70a8b..e010d0a 100644
--- a/base/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex
@@ -136,7 +136,7 @@ defmodule AddReactionPayload do
 
   def from_map(m) do
     %AddReactionPayload{
-      client_mutation_id: m["clientMutationId"],
+      client_mutation_id: Map.fetch!(m, "clientMutationId"),
       reaction: Reaction.from_map(m["reaction"]),
       subject: Reactable.from_map(m["subject"]),
     }
diff --git a/head/schema-cplusplus/test/inputs/schema/keyword-unions.schema/default/quicktype.hpp b/head/schema-cplusplus/test/inputs/schema/keyword-unions.schema/default/quicktype.hpp
new file mode 100644
index 0000000..52128a5
--- /dev/null
+++ b/head/schema-cplusplus/test/inputs/schema/keyword-unions.schema/default/quicktype.hpp
@@ -0,0 +1,16407 @@
+//  To parse this JSON data, first install
+//
+//      json.hpp  https://github.com/nlohmann/json
+//
+//  Then include this file, and then do
+//
+//     TopLevel data = nlohmann::json::parse(jsonString);
+
+#pragma once
+
+#include <optional>
+#include <variant>
+#include "json.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <regex>
+
+#ifndef NLOHMANN_OPT_HELPER
+#define NLOHMANN_OPT_HELPER
+namespace nlohmann {
+    template <typename T>
+    struct adl_serializer<std::shared_ptr<T>> {
+        static void to_json(json & j, const std::shared_ptr<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::shared_ptr<T> from_json(const json & j) {
+            if (j.is_null()) return std::shared_ptr<T>(); else return std::make_shared<T>(j.get<T>());
+        }
+    };
+    template <typename T>
+    struct adl_serializer<std::optional<T>> {
+        static void to_json(json & j, const std::optional<T> & opt) {
+            if (!opt) j = nullptr; else j = *opt;
+        }
+
+        static std::optional<T> from_json(const json & j) {
+            if (j.is_null()) return std::optional<T>(); else return std::make_optional<T>(j.get<T>());
+        }
+    };
+}
+#endif
+
+namespace quicktype {
+    using nlohmann::json;
+
+    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
+    #define NLOHMANN_UNTYPED_quicktype_HELPER
+    inline json get_untyped(const json & j, const char * property) {
+        if (j.find(property) != j.end()) {
+            return j.at(property).get<json>();
+        }
+        return json();
+    }
+
+    inline json get_untyped(const json & j, std::string property) {
+        return get_untyped(j, property.data());
+    }
+    #endif
+
+    #ifndef NLOHMANN_OPTIONAL_quicktype_HELPER
+    #define NLOHMANN_OPTIONAL_quicktype_HELPER
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::shared_ptr<T>>();
+        }
+        return std::shared_ptr<T>();
+    }
+
+    template <typename T>
+    inline std::shared_ptr<T> get_heap_optional(const json & j, std::string property) {
+        return get_heap_optional<T>(j, property.data());
+    }
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, const char * property) {
+        auto it = j.find(property);
+        if (it != j.end() && !it->is_null()) {
+            return j.at(property).get<std::optional<T>>();
+        }
+        return std::optional<T>();
+    }
+
+    template <typename T>
+    inline std::optional<T> get_stack_optional(const json & j, std::string property) {
+        return get_stack_optional<T>(j, property.data());
+    }
+    #endif
+
+    class Abstract {
+        public:
+        Abstract() = default;
+        virtual ~Abstract() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAbstract = std::variant<Abstract, double>;
+
+    class Any {
+        public:
+        Any() = default;
+        virtual ~Any() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAny = std::variant<Any, double>;
+
+    class Array {
+        public:
+        Array() = default;
+        virtual ~Array() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionArray = std::variant<Array, double>;
+
+    class As {
+        public:
+        As() = default;
+        virtual ~As() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAs = std::variant<As, double>;
+
+    class Assert {
+        public:
+        Assert() = default;
+        virtual ~Assert() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAssert = std::variant<Assert, double>;
+
+    class Associatedtype {
+        public:
+        Associatedtype() = default;
+        virtual ~Associatedtype() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAssociatedtype = std::variant<Associatedtype, double>;
+
+    class Associativity {
+        public:
+        Associativity() = default;
+        virtual ~Associativity() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAssociativity = std::variant<Associativity, double>;
+
+    class Async {
+        public:
+        Async() = default;
+        virtual ~Async() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAsync = std::variant<Async, double>;
+
+    class Atomic {
+        public:
+        Atomic() = default;
+        virtual ~Atomic() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAtomic = std::variant<Atomic, double>;
+
+    class Await {
+        public:
+        Await() = default;
+        virtual ~Await() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAwait = std::variant<Await, double>;
+
+    class Base {
+        public:
+        Base() = default;
+        virtual ~Base() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBase = std::variant<Base, double>;
+
+    class Boolean {
+        public:
+        Boolean() = default;
+        virtual ~Boolean() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBoolean = std::variant<Boolean, double>;
+
+    class Bycopy {
+        public:
+        Bycopy() = default;
+        virtual ~Bycopy() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBycopy = std::variant<Bycopy, double>;
+
+    class Byref {
+        public:
+        Byref() = default;
+        virtual ~Byref() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionByref = std::variant<Byref, double>;
+
+    class Byte {
+        public:
+        Byte() = default;
+        virtual ~Byte() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionByte = std::variant<Byte, double>;
+
+    class Chan {
+        public:
+        Chan() = default;
+        virtual ~Chan() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionChan = std::variant<Chan, double>;
+
+    class Checked {
+        public:
+        Checked() = default;
+        virtual ~Checked() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionChecked = std::variant<Checked, double>;
+
+    class Complex {
+        public:
+        Complex() = default;
+        virtual ~Complex() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionComplex = std::variant<Complex, double>;
+
+    class Console {
+        public:
+        Console() = default;
+        virtual ~Console() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConsole = std::variant<Console, double>;
+
+    class Constructor {
+        public:
+        Constructor() = default;
+        virtual ~Constructor() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConstructor = std::variant<Constructor, double>;
+
+    class Convenience {
+        public:
+        Convenience() = default;
+        virtual ~Convenience() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConvenience = std::variant<Convenience, double>;
+
+    class Convert {
+        public:
+        Convert() = default;
+        virtual ~Convert() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConvert = std::variant<Convert, double>;
+
+    class Converter {
+        public:
+        Converter() = default;
+        virtual ~Converter() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConverter = std::variant<Converter, double>;
+
+    class Date {
+        public:
+        Date() = default;
+        virtual ~Date() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDate = std::variant<Date, double>;
+
+    class DateParseHandling {
+        public:
+        DateParseHandling() = default;
+        virtual ~DateParseHandling() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDateParseHandling = std::variant<DateParseHandling, double>;
+
+    class Debugger {
+        public:
+        Debugger() = default;
+        virtual ~Debugger() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDebugger = std::variant<Debugger, double>;
+
+    class Decimal {
+        public:
+        Decimal() = default;
+        virtual ~Decimal() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDecimal = std::variant<Decimal, double>;
+
+    class Declare {
+        public:
+        Declare() = default;
+        virtual ~Declare() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDeclare = std::variant<Declare, double>;
+
+    class DecodeString {
+        public:
+        DecodeString() = default;
+        virtual ~DecodeString() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDecodeString = std::variant<DecodeString, double>;
+
+    class Def {
+        public:
+        Def() = default;
+        virtual ~Def() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDef = std::variant<Def, double>;
+
+    class Defer {
+        public:
+        Defer() = default;
+        virtual ~Defer() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDefer = std::variant<Defer, double>;
+
+    class Deinit {
+        public:
+        Deinit() = default;
+        virtual ~Deinit() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDeinit = std::variant<Deinit, double>;
+
+    class Del {
+        public:
+        Del() = default;
+        virtual ~Del() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDel = std::variant<Del, double>;
+
+    class Delegate {
+        public:
+        Delegate() = default;
+        virtual ~Delegate() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDelegate = std::variant<Delegate, double>;
+
+    class Dict {
+        public:
+        Dict() = default;
+        virtual ~Dict() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDict = std::variant<Dict, double>;
+
+    class Dictionary {
+        public:
+        Dictionary() = default;
+        virtual ~Dictionary() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDictionary = std::variant<Dictionary, double>;
+
+    class DidSet {
+        public:
+        DidSet() = default;
+        virtual ~DidSet() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDidSet = std::variant<DidSet, double>;
+
+    class Dynamic {
+        public:
+        Dynamic() = default;
+        virtual ~Dynamic() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDynamic = std::variant<Dynamic, double>;
+
+    class Elif {
+        public:
+        Elif() = default;
+        virtual ~Elif() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionElif = std::variant<Elif, double>;
+
+    class Empty {
+        public:
+        Empty() = default;
+        virtual ~Empty() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUnion = std::variant<Empty, double>;
+
+    class EncodeQuickType {
+        public:
+        EncodeQuickType() = default;
+        virtual ~EncodeQuickType() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionEncodeQuickType = std::variant<EncodeQuickType, double>;
+
+    class Event {
+        public:
+        Event() = default;
+        virtual ~Event() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionEvent = std::variant<Event, double>;
+
+    class Except {
+        public:
+        Except() = default;
+        virtual ~Except() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExcept = std::variant<Except, double>;
+
+    class Exception {
+        public:
+        Exception() = default;
+        virtual ~Exception() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionException = std::variant<Exception, double>;
+
+    class Exposing {
+        public:
+        Exposing() = default;
+        virtual ~Exposing() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExposing = std::variant<Exposing, double>;
+
+    class Extends {
+        public:
+        Extends() = default;
+        virtual ~Extends() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExtends = std::variant<Extends, double>;
+
+    class Extension {
+        public:
+        Extension() = default;
+        virtual ~Extension() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExtension = std::variant<Extension, double>;
+
+    class Fallthrough {
+        public:
+        Fallthrough() = default;
+        virtual ~Fallthrough() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFallthrough = std::variant<Fallthrough, double>;
+
+    class Fileprivate {
+        public:
+        Fileprivate() = default;
+        virtual ~Fileprivate() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFileprivate = std::variant<Fileprivate, double>;
+
+    class Finally {
+        public:
+        Finally() = default;
+        virtual ~Finally() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFinally = std::variant<Finally, double>;
+
+    class Fixed {
+        public:
+        Fixed() = default;
+        virtual ~Fixed() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFixed = std::variant<Fixed, double>;
+
+    class UnionBoolBool {
+        public:
+        UnionBoolBool() = default;
+        virtual ~UnionBoolBool() = default;
+
+        private:
+
+        public:
+    };
+
+    using TopLevelUnionBool = std::variant<UnionBoolBool, double>;
+
+    class Foreach {
+        public:
+        Foreach() = default;
+        virtual ~Foreach() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionForeach = std::variant<Foreach, double>;
+
+    class From {
+        public:
+        From() = default;
+        virtual ~From() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFrom = std::variant<From, double>;
+
+    class FromJson {
+        public:
+        FromJson() = default;
+        virtual ~FromJson() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFromJson = std::variant<FromJson, double>;
+
+    class Func {
+        public:
+        Func() = default;
+        virtual ~Func() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFunc = std::variant<Func, double>;
+
+    class Function {
+        public:
+        Function() = default;
+        virtual ~Function() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFunction = std::variant<Function, double>;
+
+    class Get {
+        public:
+        Get() = default;
+        virtual ~Get() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionGet = std::variant<Get, double>;
+
+    class Global {
+        public:
+        Global() = default;
+        virtual ~Global() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionGlobal = std::variant<Global, double>;
+
+    class Go {
+        public:
+        Go() = default;
+        virtual ~Go() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionGo = std::variant<Go, double>;
+
+    class Guard {
+        public:
+        Guard() = default;
+        virtual ~Guard() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionGuard = std::variant<Guard, double>;
+
+    class HasOwnProperty {
+        public:
+        HasOwnProperty() = default;
+        virtual ~HasOwnProperty() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionHasOwnProperty = std::variant<HasOwnProperty, double>;
+
+    class Id {
+        public:
+        Id() = default;
+        virtual ~Id() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionId = std::variant<Id, double>;
+
+    class Imaginery {
+        public:
+        Imaginery() = default;
+        virtual ~Imaginery() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionImaginery = std::variant<Imaginery, double>;
+
+    class Imp {
+        public:
+        Imp() = default;
+        virtual ~Imp() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionImp = std::variant<Imp, double>;
+
+    class Implements {
+        public:
+        Implements() = default;
+        virtual ~Implements() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionImplements = std::variant<Implements, double>;
+
+    class Implicit {
+        public:
+        Implicit() = default;
+        virtual ~Implicit() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionImplicit = std::variant<Implicit, double>;
+
+    class In {
+        public:
+        In() = default;
+        virtual ~In() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionIn = std::variant<In, double>;
+
+    class Indirect {
+        public:
+        Indirect() = default;
+        virtual ~Indirect() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionIndirect = std::variant<Indirect, double>;
+
+    class Infix {
+        public:
+        Infix() = default;
+        virtual ~Infix() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInfix = std::variant<Infix, double>;
+
+    class Init {
+        public:
+        Init() = default;
+        virtual ~Init() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInit = std::variant<Init, double>;
+
+    class Inout {
+        public:
+        Inout() = default;
+        virtual ~Inout() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInout = std::variant<Inout, double>;
+
+    class Instanceof {
+        public:
+        Instanceof() = default;
+        virtual ~Instanceof() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInstanceof = std::variant<Instanceof, double>;
+
+    class Interface {
+        public:
+        Interface() = default;
+        virtual ~Interface() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInterface = std::variant<Interface, double>;
+
+    class Internal {
+        public:
+        Internal() = default;
+        virtual ~Internal() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInternal = std::variant<Internal, double>;
+
+    class Is {
+        public:
+        Is() = default;
+        virtual ~Is() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionIs = std::variant<Is, double>;
+
+    class Iterable {
+        public:
+        Iterable() = default;
+        virtual ~Iterable() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionIterable = std::variant<Iterable, double>;
+
+    class Jdec {
+        public:
+        Jdec() = default;
+        virtual ~Jdec() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJdec = std::variant<Jdec, double>;
+
+    class Jenc {
+        public:
+        Jenc() = default;
+        virtual ~Jenc() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJenc = std::variant<Jenc, double>;
+
+    class Jpipe {
+        public:
+        Jpipe() = default;
+        virtual ~Jpipe() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJpipe = std::variant<Jpipe, double>;
+
+    class Json {
+        public:
+        Json() = default;
+        virtual ~Json() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJson = std::variant<Json, double>;
+
+    class JsonConverter {
+        public:
+        JsonConverter() = default;
+        virtual ~JsonConverter() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJsonConverter = std::variant<JsonConverter, double>;
+
+    class JsonSerializer {
+        public:
+        JsonSerializer() = default;
+        virtual ~JsonSerializer() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJsonSerializer = std::variant<JsonSerializer, double>;
+
+    class JsonToken {
+        public:
+        JsonToken() = default;
+        virtual ~JsonToken() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJsonToken = std::variant<JsonToken, double>;
+
+    class JsonWriter {
+        public:
+        JsonWriter() = default;
+        virtual ~JsonWriter() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionJsonWriter = std::variant<JsonWriter, double>;
+
+    class Lambda {
+        public:
+        Lambda() = default;
+        virtual ~Lambda() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionLambda = std::variant<Lambda, double>;
+
+    class Lazy {
+        public:
+        Lazy() = default;
+        virtual ~Lazy() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionLazy = std::variant<Lazy, double>;
+
+    class Left {
+        public:
+        Left() = default;
+        virtual ~Left() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionLeft = std::variant<Left, double>;
+
+    class Let {
+        public:
+        Let() = default;
+        virtual ~Let() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionLet = std::variant<Let, double>;
+
+    class List {
+        public:
+        List() = default;
+        virtual ~List() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionList = std::variant<List, double>;
+
+    class Lock {
+        public:
+        Lock() = default;
+        virtual ~Lock() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionLock = std::variant<Lock, double>;
+
+    class Map {
+        public:
+        Map() = default;
+        virtual ~Map() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionMap = std::variant<Map, double>;
+
+    class MetadataPropertyHandling {
+        public:
+        MetadataPropertyHandling() = default;
+        virtual ~MetadataPropertyHandling() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionMetadataPropertyHandling = std::variant<MetadataPropertyHandling, double>;
+
+    class Mutating {
+        public:
+        Mutating() = default;
+        virtual ~Mutating() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionMutating = std::variant<Mutating, double>;
+
+    class Native {
+        public:
+        Native() = default;
+        virtual ~Native() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNative = std::variant<Native, double>;
+
+    class Newtonsoft {
+        public:
+        Newtonsoft() = default;
+        virtual ~Newtonsoft() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNewtonsoft = std::variant<Newtonsoft, double>;
+
+    class Nil {
+        public:
+        Nil() = default;
+        virtual ~Nil() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNil = std::variant<Nil, double>;
+
+    class No {
+        public:
+        No() = default;
+        virtual ~No() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNo = std::variant<No, double>;
+
+    class Nonatomic {
+        public:
+        Nonatomic() = default;
+        virtual ~Nonatomic() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNonatomic = std::variant<Nonatomic, double>;
+
+    class None {
+        public:
+        None() = default;
+        virtual ~None() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNone = std::variant<None, double>;
+
+    class Nonlocal {
+        public:
+        Nonlocal() = default;
+        virtual ~Nonlocal() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNonlocal = std::variant<Nonlocal, double>;
+
+    class Nonmutating {
+        public:
+        Nonmutating() = default;
+        virtual ~Nonmutating() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNonmutating = std::variant<Nonmutating, double>;
+
+    class NsString {
+        public:
+        NsString() = default;
+        virtual ~NsString() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNsString = std::variant<NsString, double>;
+
+    class Null {
+        public:
+        Null() = default;
+        virtual ~Null() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNull = std::variant<Null, double>;
+
+    class Number {
+        public:
+        Number() = default;
+        virtual ~Number() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNumber = std::variant<Number, double>;
+
+    class Object {
+        public:
+        Object() = default;
+        virtual ~Object() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionObject = std::variant<Object, double>;
+
+    class Of {
+        public:
+        Of() = default;
+        virtual ~Of() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOf = std::variant<Of, double>;
+
+    class Oneway {
+        public:
+        Oneway() = default;
+        virtual ~Oneway() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOneway = std::variant<Oneway, double>;
+
+    class Open {
+        public:
+        Open() = default;
+        virtual ~Open() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOpen = std::variant<Open, double>;
+
+    class Optional {
+        public:
+        Optional() = default;
+        virtual ~Optional() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOptional = std::variant<Optional, double>;
+
+    class Out {
+        public:
+        Out() = default;
+        virtual ~Out() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOut = std::variant<Out, double>;
+
+    class Package {
+        public:
+        Package() = default;
+        virtual ~Package() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPackage = std::variant<Package, double>;
+
+    class Params {
+        public:
+        Params() = default;
+        virtual ~Params() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionParams = std::variant<Params, double>;
+
+    class Pass {
+        public:
+        Pass() = default;
+        virtual ~Pass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPass = std::variant<Pass, double>;
+
+    class Port {
+        public:
+        Port() = default;
+        virtual ~Port() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPort = std::variant<Port, double>;
+
+    class Postfix {
+        public:
+        Postfix() = default;
+        virtual ~Postfix() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPostfix = std::variant<Postfix, double>;
+
+    class Precedence {
+        public:
+        Precedence() = default;
+        virtual ~Precedence() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPrecedence = std::variant<Precedence, double>;
+
+    class Prefix {
+        public:
+        Prefix() = default;
+        virtual ~Prefix() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPrefix = std::variant<Prefix, double>;
+
+    class Print {
+        public:
+        Print() = default;
+        virtual ~Print() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPrint = std::variant<Print, double>;
+
+    class Printf {
+        public:
+        Printf() = default;
+        virtual ~Printf() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPrintf = std::variant<Printf, double>;
+
+    class Protocol {
+        public:
+        Protocol() = default;
+        virtual ~Protocol() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionProtocol = std::variant<Protocol, double>;
+
+    class BoolClass {
+        public:
+        BoolClass() = default;
+        virtual ~BoolClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBoolUnion = std::variant<BoolClass, double>;
+
+    class ClassClass {
+        public:
+        ClassClass() = default;
+        virtual ~ClassClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionClassUnion = std::variant<ClassClass, double>;
+
+    class FalseClass {
+        public:
+        FalseClass() = default;
+        virtual ~FalseClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFalseUnion = std::variant<FalseClass, double>;
+
+    class TrueClass {
+        public:
+        TrueClass() = default;
+        virtual ~TrueClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTrueUnion = std::variant<TrueClass, double>;
+
+    class Quicktype {
+        public:
+        Quicktype() = default;
+        virtual ~Quicktype() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionQuicktype = std::variant<Quicktype, double>;
+
+    class Raise {
+        public:
+        Raise() = default;
+        virtual ~Raise() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRaise = std::variant<Raise, double>;
+
+    class Range {
+        public:
+        Range() = default;
+        virtual ~Range() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRange = std::variant<Range, double>;
+
+    class Readonly {
+        public:
+        Readonly() = default;
+        virtual ~Readonly() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionReadonly = std::variant<Readonly, double>;
+
+    class Ref {
+        public:
+        Ref() = default;
+        virtual ~Ref() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRef = std::variant<Ref, double>;
+
+    class Repeat {
+        public:
+        Repeat() = default;
+        virtual ~Repeat() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRepeat = std::variant<Repeat, double>;
+
+    class Require {
+        public:
+        Require() = default;
+        virtual ~Require() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRequire = std::variant<Require, double>;
+
+    class Required {
+        public:
+        Required() = default;
+        virtual ~Required() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRequired = std::variant<Required, double>;
+
+    class Restrict {
+        public:
+        Restrict() = default;
+        virtual ~Restrict() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRestrict = std::variant<Restrict, double>;
+
+    class Retain {
+        public:
+        Retain() = default;
+        virtual ~Retain() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRetain = std::variant<Retain, double>;
+
+    class Rethrows {
+        public:
+        Rethrows() = default;
+        virtual ~Rethrows() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRethrows = std::variant<Rethrows, double>;
+
+    class Right {
+        public:
+        Right() = default;
+        virtual ~Right() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRight = std::variant<Right, double>;
+
+    class Sbyte {
+        public:
+        Sbyte() = default;
+        virtual ~Sbyte() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSbyte = std::variant<Sbyte, double>;
+
+    class Sealed {
+        public:
+        Sealed() = default;
+        virtual ~Sealed() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSealed = std::variant<Sealed, double>;
+
+    class Sel {
+        public:
+        Sel() = default;
+        virtual ~Sel() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSel = std::variant<Sel, double>;
+
+    class Select {
+        public:
+        Select() = default;
+        virtual ~Select() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSelect = std::variant<Select, double>;
+
+    class Self {
+        public:
+        Self() = default;
+        virtual ~Self() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSelf = std::variant<Self, double>;
+
+    class Serialize {
+        public:
+        Serialize() = default;
+        virtual ~Serialize() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSerialize = std::variant<Serialize, double>;
+
+    class Set {
+        public:
+        Set() = default;
+        virtual ~Set() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSet = std::variant<Set, double>;
+
+    class Stackalloc {
+        public:
+        Stackalloc() = default;
+        virtual ~Stackalloc() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionStackalloc = std::variant<Stackalloc, double>;
+
+    class Strictfp {
+        public:
+        Strictfp() = default;
+        virtual ~Strictfp() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionStrictfp = std::variant<Strictfp, double>;
+
+    class String {
+        public:
+        String() = default;
+        virtual ~String() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionString = std::variant<String, double>;
+
+    class Subscript {
+        public:
+        Subscript() = default;
+        virtual ~Subscript() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSubscript = std::variant<Subscript, double>;
+
+    class Super {
+        public:
+        Super() = default;
+        virtual ~Super() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSuper = std::variant<Super, double>;
+
+    class Symbol {
+        public:
+        Symbol() = default;
+        virtual ~Symbol() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSymbol = std::variant<Symbol, double>;
+
+    class System {
+        public:
+        System() = default;
+        virtual ~System() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSystem = std::variant<System, double>;
+
+    class Then {
+        public:
+        Then() = default;
+        virtual ~Then() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionThen = std::variant<Then, double>;
+
+    class Throws {
+        public:
+        Throws() = default;
+        virtual ~Throws() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionThrows = std::variant<Throws, double>;
+
+    class ToJson {
+        public:
+        ToJson() = default;
+        virtual ~ToJson() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionToJson = std::variant<ToJson, double>;
+
+    class TopLevelClass {
+        public:
+        TopLevelClass() = default;
+        virtual ~TopLevelClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTopLevel = std::variant<TopLevelClass, double>;
+
+    class Alignas {
+        public:
+        Alignas() = default;
+        virtual ~Alignas() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAlignas = std::variant<Alignas, double>;
+
+    class Alignof {
+        public:
+        Alignof() = default;
+        virtual ~Alignof() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAlignof = std::variant<Alignof, double>;
+
+    class And {
+        public:
+        And() = default;
+        virtual ~And() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAnd = std::variant<And, double>;
+
+    class AndEq {
+        public:
+        AndEq() = default;
+        virtual ~AndEq() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAndEq = std::variant<AndEq, double>;
+
+    class AnyClass {
+        public:
+        AnyClass() = default;
+        virtual ~AnyClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAnyUnion = std::variant<AnyClass, double>;
+
+    class Asm {
+        public:
+        Asm() = default;
+        virtual ~Asm() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAsm = std::variant<Asm, double>;
+
+    class AtomicCancel {
+        public:
+        AtomicCancel() = default;
+        virtual ~AtomicCancel() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAtomicCancel = std::variant<AtomicCancel, double>;
+
+    class AtomicCommit {
+        public:
+        AtomicCommit() = default;
+        virtual ~AtomicCommit() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAtomicCommit = std::variant<AtomicCommit, double>;
+
+    class AtomicNoexcept {
+        public:
+        AtomicNoexcept() = default;
+        virtual ~AtomicNoexcept() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAtomicNoexcept = std::variant<AtomicNoexcept, double>;
+
+    class Auto {
+        public:
+        Auto() = default;
+        virtual ~Auto() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionAuto = std::variant<Auto, double>;
+
+    class Bitand {
+        public:
+        Bitand() = default;
+        virtual ~Bitand() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBitand = std::variant<Bitand, double>;
+
+    class Bitor {
+        public:
+        Bitor() = default;
+        virtual ~Bitor() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBitor = std::variant<Bitor, double>;
+
+    class Bool {
+        public:
+        Bool() = default;
+        virtual ~Bool() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBool = std::variant<Bool, double>;
+
+    class Break {
+        public:
+        Break() = default;
+        virtual ~Break() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionBreak = std::variant<Break, double>;
+
+    class Case {
+        public:
+        Case() = default;
+        virtual ~Case() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionCase = std::variant<Case, double>;
+
+    class Catch {
+        public:
+        Catch() = default;
+        virtual ~Catch() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionCatch = std::variant<Catch, double>;
+
+    class Char {
+        public:
+        Char() = default;
+        virtual ~Char() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionChar = std::variant<Char, double>;
+
+    class Char16T {
+        public:
+        Char16T() = default;
+        virtual ~Char16T() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionChar16T = std::variant<Char16T, double>;
+
+    class Char32T {
+        public:
+        Char32T() = default;
+        virtual ~Char32T() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionChar32T = std::variant<Char32T, double>;
+
+    class Class {
+        public:
+        Class() = default;
+        virtual ~Class() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionClass = std::variant<Class, double>;
+
+    class CoAwait {
+        public:
+        CoAwait() = default;
+        virtual ~CoAwait() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionCoAwait = std::variant<CoAwait, double>;
+
+    class CoReturn {
+        public:
+        CoReturn() = default;
+        virtual ~CoReturn() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionCoReturn = std::variant<CoReturn, double>;
+
+    class CoYield {
+        public:
+        CoYield() = default;
+        virtual ~CoYield() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionCoYield = std::variant<CoYield, double>;
+
+    class Compl {
+        public:
+        Compl() = default;
+        virtual ~Compl() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionCompl = std::variant<Compl, double>;
+
+    class Concept {
+        public:
+        Concept() = default;
+        virtual ~Concept() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConcept = std::variant<Concept, double>;
+
+    class Const {
+        public:
+        Const() = default;
+        virtual ~Const() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConst = std::variant<Const, double>;
+
+    class ConstCast {
+        public:
+        ConstCast() = default;
+        virtual ~ConstCast() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConstCast = std::variant<ConstCast, double>;
+
+    class Constexpr {
+        public:
+        Constexpr() = default;
+        virtual ~Constexpr() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionConstexpr = std::variant<Constexpr, double>;
+
+    class Continue {
+        public:
+        Continue() = default;
+        virtual ~Continue() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionContinue = std::variant<Continue, double>;
+
+    class Decltype {
+        public:
+        Decltype() = default;
+        virtual ~Decltype() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDecltype = std::variant<Decltype, double>;
+
+    class Default {
+        public:
+        Default() = default;
+        virtual ~Default() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDefault = std::variant<Default, double>;
+
+    class Delete {
+        public:
+        Delete() = default;
+        virtual ~Delete() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDelete = std::variant<Delete, double>;
+
+    class Do {
+        public:
+        Do() = default;
+        virtual ~Do() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDo = std::variant<Do, double>;
+
+    class Double {
+        public:
+        Double() = default;
+        virtual ~Double() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDouble = std::variant<Double, double>;
+
+    class DynamicCast {
+        public:
+        DynamicCast() = default;
+        virtual ~DynamicCast() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionDynamicCast = std::variant<DynamicCast, double>;
+
+    class Else {
+        public:
+        Else() = default;
+        virtual ~Else() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionElse = std::variant<Else, double>;
+
+    class Enum {
+        public:
+        Enum() = default;
+        virtual ~Enum() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionEnum = std::variant<Enum, double>;
+
+    class Explicit {
+        public:
+        Explicit() = default;
+        virtual ~Explicit() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExplicit = std::variant<Explicit, double>;
+
+    class Export {
+        public:
+        Export() = default;
+        virtual ~Export() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExport = std::variant<Export, double>;
+
+    class Extern {
+        public:
+        Extern() = default;
+        virtual ~Extern() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionExtern = std::variant<Extern, double>;
+
+    class False {
+        public:
+        False() = default;
+        virtual ~False() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFalse = std::variant<False, double>;
+
+    class Final {
+        public:
+        Final() = default;
+        virtual ~Final() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFinal = std::variant<Final, double>;
+
+    class Float {
+        public:
+        Float() = default;
+        virtual ~Float() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFloat = std::variant<Float, double>;
+
+    class For {
+        public:
+        For() = default;
+        virtual ~For() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFor = std::variant<For, double>;
+
+    class Friend {
+        public:
+        Friend() = default;
+        virtual ~Friend() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionFriend = std::variant<Friend, double>;
+
+    class Goto {
+        public:
+        Goto() = default;
+        virtual ~Goto() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionGoto = std::variant<Goto, double>;
+
+    class If {
+        public:
+        If() = default;
+        virtual ~If() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionIf = std::variant<If, double>;
+
+    class Import {
+        public:
+        Import() = default;
+        virtual ~Import() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionImport = std::variant<Import, double>;
+
+    class Inline {
+        public:
+        Inline() = default;
+        virtual ~Inline() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInline = std::variant<Inline, double>;
+
+    class Int {
+        public:
+        Int() = default;
+        virtual ~Int() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionInt = std::variant<Int, double>;
+
+    class Long {
+        public:
+        Long() = default;
+        virtual ~Long() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionLong = std::variant<Long, double>;
+
+    class Module {
+        public:
+        Module() = default;
+        virtual ~Module() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionModule = std::variant<Module, double>;
+
+    class Mutable {
+        public:
+        Mutable() = default;
+        virtual ~Mutable() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionMutable = std::variant<Mutable, double>;
+
+    class Namespace {
+        public:
+        Namespace() = default;
+        virtual ~Namespace() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNamespace = std::variant<Namespace, double>;
+
+    class New {
+        public:
+        New() = default;
+        virtual ~New() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNew = std::variant<New, double>;
+
+    class Noexcept {
+        public:
+        Noexcept() = default;
+        virtual ~Noexcept() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNoexcept = std::variant<Noexcept, double>;
+
+    class NoneClass {
+        public:
+        NoneClass() = default;
+        virtual ~NoneClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNoneUnion = std::variant<NoneClass, double>;
+
+    class Not {
+        public:
+        Not() = default;
+        virtual ~Not() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNot = std::variant<Not, double>;
+
+    class NotEq {
+        public:
+        NotEq() = default;
+        virtual ~NotEq() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNotEq = std::variant<NotEq, double>;
+
+    class NullClass {
+        public:
+        NullClass() = default;
+        virtual ~NullClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNullUnion = std::variant<NullClass, double>;
+
+    class Nullptr {
+        public:
+        Nullptr() = default;
+        virtual ~Nullptr() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionNullptr = std::variant<Nullptr, double>;
+
+    class Operator {
+        public:
+        Operator() = default;
+        virtual ~Operator() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOperator = std::variant<Operator, double>;
+
+    class Or {
+        public:
+        Or() = default;
+        virtual ~Or() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOr = std::variant<Or, double>;
+
+    class OrEq {
+        public:
+        OrEq() = default;
+        virtual ~OrEq() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOrEq = std::variant<OrEq, double>;
+
+    class Override {
+        public:
+        Override() = default;
+        virtual ~Override() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionOverride = std::variant<Override, double>;
+
+    class Private {
+        public:
+        Private() = default;
+        virtual ~Private() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPrivate = std::variant<Private, double>;
+
+    class Protected {
+        public:
+        Protected() = default;
+        virtual ~Protected() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionProtected = std::variant<Protected, double>;
+
+    class ProtocolClass {
+        public:
+        ProtocolClass() = default;
+        virtual ~ProtocolClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionProtocolUnion = std::variant<ProtocolClass, double>;
+
+    class Public {
+        public:
+        Public() = default;
+        virtual ~Public() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionPublic = std::variant<Public, double>;
+
+    class Register {
+        public:
+        Register() = default;
+        virtual ~Register() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRegister = std::variant<Register, double>;
+
+    class ReinterpretCast {
+        public:
+        ReinterpretCast() = default;
+        virtual ~ReinterpretCast() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionReinterpretCast = std::variant<ReinterpretCast, double>;
+
+    class Requires {
+        public:
+        Requires() = default;
+        virtual ~Requires() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionRequires = std::variant<Requires, double>;
+
+    class Return {
+        public:
+        Return() = default;
+        virtual ~Return() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionReturn = std::variant<Return, double>;
+
+    class SelfClass {
+        public:
+        SelfClass() = default;
+        virtual ~SelfClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSelfUnion = std::variant<SelfClass, double>;
+
+    class Short {
+        public:
+        Short() = default;
+        virtual ~Short() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionShort = std::variant<Short, double>;
+
+    class Signed {
+        public:
+        Signed() = default;
+        virtual ~Signed() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSigned = std::variant<Signed, double>;
+
+    class Sizeof {
+        public:
+        Sizeof() = default;
+        virtual ~Sizeof() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSizeof = std::variant<Sizeof, double>;
+
+    class Static {
+        public:
+        Static() = default;
+        virtual ~Static() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionStatic = std::variant<Static, double>;
+
+    class StaticAssert {
+        public:
+        StaticAssert() = default;
+        virtual ~StaticAssert() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionStaticAssert = std::variant<StaticAssert, double>;
+
+    class StaticCast {
+        public:
+        StaticCast() = default;
+        virtual ~StaticCast() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionStaticCast = std::variant<StaticCast, double>;
+
+    class Struct {
+        public:
+        Struct() = default;
+        virtual ~Struct() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionStruct = std::variant<Struct, double>;
+
+    class Switch {
+        public:
+        Switch() = default;
+        virtual ~Switch() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSwitch = std::variant<Switch, double>;
+
+    class Synchronized {
+        public:
+        Synchronized() = default;
+        virtual ~Synchronized() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionSynchronized = std::variant<Synchronized, double>;
+
+    class Template {
+        public:
+        Template() = default;
+        virtual ~Template() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTemplate = std::variant<Template, double>;
+
+    class This {
+        public:
+        This() = default;
+        virtual ~This() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionThis = std::variant<This, double>;
+
+    class ThreadLocal {
+        public:
+        ThreadLocal() = default;
+        virtual ~ThreadLocal() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionThreadLocal = std::variant<ThreadLocal, double>;
+
+    class Throw {
+        public:
+        Throw() = default;
+        virtual ~Throw() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionThrow = std::variant<Throw, double>;
+
+    class True {
+        public:
+        True() = default;
+        virtual ~True() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTrue = std::variant<True, double>;
+
+    class Try {
+        public:
+        Try() = default;
+        virtual ~Try() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTry = std::variant<Try, double>;
+
+    class TypeClass {
+        public:
+        TypeClass() = default;
+        virtual ~TypeClass() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTypeUnion = std::variant<TypeClass, double>;
+
+    class Typedef {
+        public:
+        Typedef() = default;
+        virtual ~Typedef() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTypedef = std::variant<Typedef, double>;
+
+    class Typeid {
+        public:
+        Typeid() = default;
+        virtual ~Typeid() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTypeid = std::variant<Typeid, double>;
+
+    class Typename {
+        public:
+        Typename() = default;
+        virtual ~Typename() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTypename = std::variant<Typename, double>;
+
+    class Union {
+        public:
+        Union() = default;
+        virtual ~Union() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUnionUnion = std::variant<Union, double>;
+
+    class Unsigned {
+        public:
+        Unsigned() = default;
+        virtual ~Unsigned() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUnsigned = std::variant<Unsigned, double>;
+
+    class Using {
+        public:
+        Using() = default;
+        virtual ~Using() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUsing = std::variant<Using, double>;
+
+    class Virtual {
+        public:
+        Virtual() = default;
+        virtual ~Virtual() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionVirtual = std::variant<Virtual, double>;
+
+    class Void {
+        public:
+        Void() = default;
+        virtual ~Void() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionVoid = std::variant<Void, double>;
+
+    class Volatile {
+        public:
+        Volatile() = default;
+        virtual ~Volatile() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionVolatile = std::variant<Volatile, double>;
+
+    class WcharT {
+        public:
+        WcharT() = default;
+        virtual ~WcharT() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionWcharT = std::variant<WcharT, double>;
+
+    class While {
+        public:
+        While() = default;
+        virtual ~While() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionWhile = std::variant<While, double>;
+
+    class Xor {
+        public:
+        Xor() = default;
+        virtual ~Xor() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionXor = std::variant<Xor, double>;
+
+    class XorEq {
+        public:
+        XorEq() = default;
+        virtual ~XorEq() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionXorEq = std::variant<XorEq, double>;
+
+    class Transient {
+        public:
+        Transient() = default;
+        virtual ~Transient() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTransient = std::variant<Transient, double>;
+
+    class Type {
+        public:
+        Type() = default;
+        virtual ~Type() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionType = std::variant<Type, double>;
+
+    class Typealias {
+        public:
+        Typealias() = default;
+        virtual ~Typealias() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTypealias = std::variant<Typealias, double>;
+
+    class Typeof {
+        public:
+        Typeof() = default;
+        virtual ~Typeof() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionTypeof = std::variant<Typeof, double>;
+
+    class Uint {
+        public:
+        Uint() = default;
+        virtual ~Uint() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUint = std::variant<Uint, double>;
+
+    class Ulong {
+        public:
+        Ulong() = default;
+        virtual ~Ulong() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUlong = std::variant<Ulong, double>;
+
+    class Unchecked {
+        public:
+        Unchecked() = default;
+        virtual ~Unchecked() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUnchecked = std::variant<Unchecked, double>;
+
+    class Undefined {
+        public:
+        Undefined() = default;
+        virtual ~Undefined() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUndefined = std::variant<Undefined, double>;
+
+    class Unowned {
+        public:
+        Unowned() = default;
+        virtual ~Unowned() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUnowned = std::variant<Unowned, double>;
+
+    class Unsafe {
+        public:
+        Unsafe() = default;
+        virtual ~Unsafe() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUnsafe = std::variant<Unsafe, double>;
+
+    class Ushort {
+        public:
+        Ushort() = default;
+        virtual ~Ushort() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionUshort = std::variant<Ushort, double>;
+
+    class Var {
+        public:
+        Var() = default;
+        virtual ~Var() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionVar = std::variant<Var, double>;
+
+    class Weak {
+        public:
+        Weak() = default;
+        virtual ~Weak() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionWeak = std::variant<Weak, double>;
+
+    class Where {
+        public:
+        Where() = default;
+        virtual ~Where() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionWhere = std::variant<Where, double>;
+
+    class WillSet {
+        public:
+        WillSet() = default;
+        virtual ~WillSet() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionWillSet = std::variant<WillSet, double>;
+
+    class With {
+        public:
+        With() = default;
+        virtual ~With() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionWith = std::variant<With, double>;
+
+    class Yes {
+        public:
+        Yes() = default;
+        virtual ~Yes() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionYes = std::variant<Yes, double>;
+
+    class Yield {
+        public:
+        Yield() = default;
+        virtual ~Yield() = default;
+
+        private:
+
+        public:
+    };
+
+    using UnionYield = std::variant<Yield, double>;
+
+    class TopLevel {
+        public:
+        TopLevel() = default;
+        virtual ~TopLevel() = default;
+
+        private:
+        std::optional<UnionUnion> empty;
+        std::optional<UnionBoolUnion> purple_bool;
+        std::optional<UnionComplex> complex;
+        std::optional<UnionImaginery> imaginery;
+        std::optional<UnionAbstract> abstract;
+        std::optional<UnionAlignas> top_level_alignas;
+        std::optional<UnionAlignof> top_level_alignof;
+        std::optional<UnionAnd> top_level_and;
+        std::optional<UnionAndEq> top_level_and_eq;
+        std::optional<UnionAnyUnion> top_level_any;
+        std::optional<UnionAny> any;
+        std::optional<UnionArray> array;
+        std::optional<UnionAs> as;
+        std::optional<UnionAsm> top_level_asm;
+        std::optional<UnionAssert> assert;
+        std::optional<UnionAssociatedtype> associatedtype;
+        std::optional<UnionAssociativity> associativity;
+        std::optional<UnionAsync> async;
+        std::optional<UnionAtomic> atomic;
+        std::optional<UnionAtomicCancel> top_level_atomic_cancel;
+        std::optional<UnionAtomicCommit> top_level_atomic_commit;
+        std::optional<UnionAtomicNoexcept> top_level_atomic_noexcept;
+        std::optional<UnionAuto> top_level_auto;
+        std::optional<UnionAwait> await;
+        std::optional<UnionBase> base;
+        std::optional<UnionBitand> top_level_bitand;
+        std::optional<UnionBitor> top_level_bitor;
+        std::optional<UnionBool> top_level_bool;
+        std::optional<TopLevelUnionBool> fluffy_bool;
+        std::optional<UnionBoolean> boolean;
+        std::optional<UnionBreak> top_level_break;
+        std::optional<UnionBycopy> bycopy;
+        std::optional<UnionByref> byref;
+        std::optional<UnionByte> byte;
+        std::optional<UnionCase> top_level_case;
+        std::optional<UnionCatch> top_level_catch;
+        std::optional<UnionChan> chan;
+        std::optional<UnionChar> top_level_char;
+        std::optional<UnionChar16T> top_level_char16_t;
+        std::optional<UnionChar32T> top_level_char32_t;
+        std::optional<UnionChecked> checked;
+        std::optional<UnionClassUnion> purple_class;
+        std::optional<UnionClass> top_level_class;
+        std::optional<UnionCoAwait> top_level_co_await;
+        std::optional<UnionCoReturn> top_level_co_return;
+        std::optional<UnionCoYield> top_level_co_yield;
+        std::optional<UnionCompl> top_level_compl;
+        std::optional<UnionConcept> top_level_concept;
+        std::optional<UnionConsole> console;
+        std::optional<UnionConst> top_level_const;
+        std::optional<UnionConstCast> top_level_const_cast;
+        std::optional<UnionConstexpr> top_level_constexpr;
+        std::optional<UnionConstructor> constructor;
+        std::optional<UnionContinue> top_level_continue;
+        std::optional<UnionConvenience> convenience;
+        std::optional<UnionConvert> convert;
+        std::optional<UnionConverter> converter;
+        std::optional<UnionDate> date;
+        std::optional<UnionDateParseHandling> date_parse_handling;
+        std::optional<UnionDebugger> debugger;
+        std::optional<UnionDecimal> decimal;
+        std::optional<UnionDeclare> declare;
+        std::optional<UnionDecltype> top_level_decltype;
+        std::optional<UnionDecodeString> decode_string;
+        std::optional<UnionDef> def;
+        std::optional<UnionDefault> top_level_default;
+        std::optional<UnionDefer> defer;
+        std::optional<UnionDeinit> deinit;
+        std::optional<UnionDel> del;
+        std::optional<UnionDelegate> delegate;
+        std::optional<UnionDelete> top_level_delete;
+        std::optional<UnionDict> dict;
+        std::optional<UnionDictionary> dictionary;
+        std::optional<UnionDidSet> did_set;
+        std::optional<UnionDo> top_level_do;
+        std::optional<UnionDouble> top_level_double;
+        std::optional<double> dummy;
+        std::optional<UnionDynamic> dynamic;
+        std::optional<UnionDynamicCast> top_level_dynamic_cast;
+        std::optional<UnionElif> elif;
+        std::optional<UnionElse> top_level_else;
+        std::optional<UnionEncodeQuickType> encode_quick_type;
+        std::optional<UnionEnum> top_level_enum;
+        std::optional<UnionEvent> event;
+        std::optional<UnionExcept> except;
+        std::optional<UnionException> exception;
+        std::optional<UnionExplicit> top_level_explicit;
+        std::optional<UnionExport> top_level_export;
+        std::optional<UnionExposing> exposing;
+        std::optional<UnionExtends> extends;
+        std::optional<UnionExtension> extension;
+        std::optional<UnionExtern> top_level_extern;
+        std::optional<UnionFallthrough> fallthrough;
+        std::optional<UnionFalseUnion> purple_false;
+        std::optional<UnionFalse> top_level_false;
+        std::optional<UnionFileprivate> fileprivate;
+        std::optional<UnionFinal> top_level_final;
+        std::optional<UnionFinally> finally;
+        std::optional<UnionFixed> fixed;
+        std::optional<UnionFloat> top_level_float;
+        std::optional<UnionFor> top_level_for;
+        std::optional<UnionForeach> foreach;
+        std::optional<UnionFriend> top_level_friend;
+        std::optional<UnionFrom> from;
+        std::optional<UnionFromJson> from_json;
+        std::optional<UnionFunc> func;
+        std::optional<UnionFunction> function;
+        std::optional<UnionGet> get;
+        std::optional<UnionGlobal> global;
+        std::optional<UnionGo> go;
+        std::optional<UnionGoto> top_level_goto;
+        std::optional<UnionGuard> guard;
+        std::optional<UnionHasOwnProperty> has_own_property;
+        std::optional<UnionId> id;
+        std::optional<UnionIf> top_level_if;
+        std::optional<UnionImp> imp;
+        std::optional<UnionImplements> implements;
+        std::optional<UnionImplicit> implicit;
+        std::optional<UnionImport> top_level_import;
+        std::optional<UnionIn> in;
+        std::optional<UnionIndirect> indirect;
+        std::optional<UnionInfix> infix;
+        std::optional<UnionInit> init;
+        std::optional<UnionInline> top_level_inline;
+        std::optional<UnionInout> inout;
+        std::optional<UnionInstanceof> instanceof;
+        std::optional<UnionInt> top_level_int;
+        std::optional<UnionInterface> interface;
+        std::optional<UnionInternal> internal;
+        std::optional<UnionIs> is;
+        std::optional<UnionIterable> iterable;
+        std::optional<UnionJdec> jdec;
+        std::optional<UnionJenc> jenc;
+        std::optional<UnionJpipe> jpipe;
+        std::optional<UnionJson> json;
+        std::optional<UnionJsonConverter> json_converter;
+        std::optional<UnionJsonSerializer> json_serializer;
+        std::optional<UnionJsonToken> json_token;
+        std::optional<UnionJsonWriter> json_writer;
+        std::optional<UnionLambda> lambda;
+        std::optional<UnionLazy> lazy;
+        std::optional<UnionLeft> left;
+        std::optional<UnionLet> let;
+        std::optional<UnionList> list;
+        std::optional<UnionLock> lock;
+        std::optional<UnionLong> top_level_long;
+        std::optional<UnionMap> map;
+        std::optional<UnionMetadataPropertyHandling> metadata_property_handling;
+        std::optional<UnionModule> top_level_module;
+        std::optional<UnionMutable> top_level_mutable;
+        std::optional<UnionMutating> mutating;
+        std::optional<UnionNamespace> top_level_namespace;
+        std::optional<UnionNative> native;
+        std::optional<UnionNew> top_level_new;
+        std::optional<UnionNewtonsoft> newtonsoft;
+        std::optional<UnionNil> nil;
+        std::optional<UnionNo> no;
+        std::optional<UnionNoexcept> top_level_noexcept;
+        std::optional<UnionNonatomic> nonatomic;
+        std::optional<UnionNoneUnion> top_level_none;
+        std::optional<UnionNone> none;
+        std::optional<UnionNonlocal> nonlocal;
+        std::optional<UnionNonmutating> nonmutating;
+        std::optional<UnionNot> top_level_not;
+        std::optional<UnionNotEq> top_level_not_eq;
+        std::optional<UnionNsString> ns_string;
+        std::optional<UnionNull> null;
+        std::optional<UnionNullUnion> top_level_null;
+        std::optional<UnionNullptr> top_level_nullptr;
+        std::optional<UnionNumber> number;
+        std::optional<UnionObject> object;
+        std::optional<UnionOf> of;
+        std::optional<UnionOneway> oneway;
+        std::optional<UnionOpen> open;
+        std::optional<UnionOperator> top_level_operator;
+        std::optional<UnionOptional> optional;
+        std::optional<UnionOr> top_level_or;
+        std::optional<UnionOrEq> top_level_or_eq;
+        std::optional<UnionOut> out;
+        std::optional<UnionOverride> top_level_override;
+        std::optional<UnionPackage> package;
+        std::optional<UnionParams> params;
+        std::optional<UnionPass> pass;
+        std::optional<UnionPort> port;
+        std::optional<UnionPostfix> postfix;
+        std::optional<UnionPrecedence> precedence;
+        std::optional<UnionPrefix> prefix;
+        std::optional<UnionPrint> print;
+        std::optional<UnionPrintf> printf;
+        std::optional<UnionPrivate> top_level_private;
+        std::optional<UnionProtected> top_level_protected;
+        std::optional<UnionProtocol> protocol;
+        std::optional<UnionProtocolUnion> top_level_protocol;
+        std::optional<UnionPublic> top_level_public;
+        std::optional<UnionQuicktype> quicktype;
+        std::optional<UnionRaise> raise;
+        std::optional<UnionRange> range;
+        std::optional<UnionReadonly> readonly;
+        std::optional<UnionRef> ref;
+        std::optional<UnionRegister> top_level_register;
+        std::optional<UnionReinterpretCast> top_level_reinterpret_cast;
+        std::optional<UnionRepeat> repeat;
+        std::optional<UnionRequire> require;
+        std::optional<UnionRequired> required;
+        std::optional<UnionRequires> top_level_requires;
+        std::optional<UnionRestrict> restrict;
+        std::optional<UnionRetain> retain;
+        std::optional<UnionRethrows> rethrows;
+        std::optional<UnionReturn> top_level_return;
+        std::optional<UnionRight> right;
+        std::optional<UnionSbyte> sbyte;
+        std::optional<UnionSealed> sealed;
+        std::optional<UnionSel> sel;
+        std::optional<UnionSelect> select;
+        std::optional<UnionSelf> self;
+        std::optional<UnionSelfUnion> top_level_self;
+        std::optional<UnionSerialize> serialize;
+        std::optional<UnionSet> set;
+        std::optional<UnionShort> top_level_short;
+        std::optional<UnionSigned> top_level_signed;
+        std::optional<UnionSizeof> top_level_sizeof;
+        std::optional<UnionStackalloc> stackalloc;
+        std::optional<UnionStatic> top_level_static;
+        std::optional<UnionStaticAssert> top_level_static_assert;
+        std::optional<UnionStaticCast> top_level_static_cast;
+        std::optional<UnionStrictfp> strictfp;
+        std::optional<UnionString> string;
+        std::optional<UnionStruct> top_level_struct;
+        std::optional<UnionSubscript> subscript;
+        std::optional<UnionSuper> super;
+        std::optional<UnionSwitch> top_level_switch;
+        std::optional<UnionSymbol> symbol;
+        std::optional<UnionSynchronized> top_level_synchronized;
+        std::optional<UnionSystem> system;
+        std::optional<UnionTemplate> top_level_template;
+        std::optional<UnionThen> then;
+        std::optional<UnionThis> top_level_this;
+        std::optional<UnionThreadLocal> top_level_thread_local;
+        std::optional<UnionThrow> top_level_throw;
+        std::optional<UnionThrows> throws;
+        std::optional<UnionToJson> to_json;
+        std::optional<UnionTopLevel> top_level;
+        std::optional<UnionTransient> transient;
+        std::optional<UnionTrue> top_level_true;
+        std::optional<UnionTrueUnion> purple_true;
+        std::optional<UnionTry> top_level_try;
+        std::optional<UnionType> type;
+        std::optional<UnionTypeUnion> top_level_type;
+        std::optional<UnionTypealias> typealias;
+        std::optional<UnionTypedef> top_level_typedef;
+        std::optional<UnionTypeid> top_level_typeid;
+        std::optional<UnionTypename> top_level_typename;
+        std::optional<UnionTypeof> typeof;
+        std::optional<UnionUint> uint;
+        std::optional<UnionUlong> ulong;
+        std::optional<UnionUnchecked> unchecked;
+        std::optional<UnionUndefined> undefined;
+        std::optional<UnionUnionUnion> top_level_union;
+        std::optional<UnionUnowned> unowned;
+        std::optional<UnionUnsafe> unsafe;
+        std::optional<UnionUnsigned> top_level_unsigned;
+        std::optional<UnionUshort> ushort;
+        std::optional<UnionUsing> top_level_using;
+        std::optional<UnionVar> var;
+        std::optional<UnionVirtual> top_level_virtual;
+        std::optional<UnionVoid> top_level_void;
+        std::optional<UnionVolatile> top_level_volatile;
+        std::optional<UnionWcharT> top_level_wchar_t;
+        std::optional<UnionWeak> weak;
+        std::optional<UnionWhere> where;
+        std::optional<UnionWhile> top_level_while;
+        std::optional<UnionWillSet> will_set;
+        std::optional<UnionWith> with;
+        std::optional<UnionXor> top_level_xor;
+        std::optional<UnionXorEq> top_level_xor_eq;
+        std::optional<UnionYes> yes;
+        std::optional<UnionYield> yield;
+
+        public:
+        const std::optional<UnionUnion> & get_empty() const { return empty; }
+        std::optional<UnionUnion> & get_mutable_empty() { return empty; }
+        void set_empty(const std::optional<UnionUnion> & value) { this->empty = value; }
+
+        const std::optional<UnionBoolUnion> & get_purple_bool() const { return purple_bool; }
+        std::optional<UnionBoolUnion> & get_mutable_purple_bool() { return purple_bool; }
+        void set_purple_bool(const std::optional<UnionBoolUnion> & value) { this->purple_bool = value; }
+
+        const std::optional<UnionComplex> & get_complex() const { return complex; }
+        std::optional<UnionComplex> & get_mutable_complex() { return complex; }
+        void set_complex(const std::optional<UnionComplex> & value) { this->complex = value; }
+
+        const std::optional<UnionImaginery> & get_imaginery() const { return imaginery; }
+        std::optional<UnionImaginery> & get_mutable_imaginery() { return imaginery; }
+        void set_imaginery(const std::optional<UnionImaginery> & value) { this->imaginery = value; }
+
+        const std::optional<UnionAbstract> & get_abstract() const { return abstract; }
+        std::optional<UnionAbstract> & get_mutable_abstract() { return abstract; }
+        void set_abstract(const std::optional<UnionAbstract> & value) { this->abstract = value; }
+
+        const std::optional<UnionAlignas> & get_top_level_alignas() const { return top_level_alignas; }
+        std::optional<UnionAlignas> & get_mutable_top_level_alignas() { return top_level_alignas; }
+        void set_top_level_alignas(const std::optional<UnionAlignas> & value) { this->top_level_alignas = value; }
+
+        const std::optional<UnionAlignof> & get_top_level_alignof() const { return top_level_alignof; }
+        std::optional<UnionAlignof> & get_mutable_top_level_alignof() { return top_level_alignof; }
+        void set_top_level_alignof(const std::optional<UnionAlignof> & value) { this->top_level_alignof = value; }
+
+        const std::optional<UnionAnd> & get_top_level_and() const { return top_level_and; }
+        std::optional<UnionAnd> & get_mutable_top_level_and() { return top_level_and; }
+        void set_top_level_and(const std::optional<UnionAnd> & value) { this->top_level_and = value; }
+
+        const std::optional<UnionAndEq> & get_top_level_and_eq() const { return top_level_and_eq; }
+        std::optional<UnionAndEq> & get_mutable_top_level_and_eq() { return top_level_and_eq; }
+        void set_top_level_and_eq(const std::optional<UnionAndEq> & value) { this->top_level_and_eq = value; }
+
+        const std::optional<UnionAnyUnion> & get_top_level_any() const { return top_level_any; }
+        std::optional<UnionAnyUnion> & get_mutable_top_level_any() { return top_level_any; }
+        void set_top_level_any(const std::optional<UnionAnyUnion> & value) { this->top_level_any = value; }
+
+        const std::optional<UnionAny> & get_any() const { return any; }
+        std::optional<UnionAny> & get_mutable_any() { return any; }
+        void set_any(const std::optional<UnionAny> & value) { this->any = value; }
+
+        const std::optional<UnionArray> & get_array() const { return array; }
+        std::optional<UnionArray> & get_mutable_array() { return array; }
+        void set_array(const std::optional<UnionArray> & value) { this->array = value; }
+
+        const std::optional<UnionAs> & get_as() const { return as; }
+        std::optional<UnionAs> & get_mutable_as() { return as; }
+        void set_as(const std::optional<UnionAs> & value) { this->as = value; }
+
+        const std::optional<UnionAsm> & get_top_level_asm() const { return top_level_asm; }
+        std::optional<UnionAsm> & get_mutable_top_level_asm() { return top_level_asm; }
+        void set_top_level_asm(const std::optional<UnionAsm> & value) { this->top_level_asm = value; }
+
+        const std::optional<UnionAssert> & get_assert() const { return assert; }
+        std::optional<UnionAssert> & get_mutable_assert() { return assert; }
+        void set_assert(const std::optional<UnionAssert> & value) { this->assert = value; }
+
+        const std::optional<UnionAssociatedtype> & get_associatedtype() const { return associatedtype; }
+        std::optional<UnionAssociatedtype> & get_mutable_associatedtype() { return associatedtype; }
+        void set_associatedtype(const std::optional<UnionAssociatedtype> & value) { this->associatedtype = value; }
+
+        const std::optional<UnionAssociativity> & get_associativity() const { return associativity; }
+        std::optional<UnionAssociativity> & get_mutable_associativity() { return associativity; }
+        void set_associativity(const std::optional<UnionAssociativity> & value) { this->associativity = value; }
+
+        const std::optional<UnionAsync> & get_async() const { return async; }
+        std::optional<UnionAsync> & get_mutable_async() { return async; }
+        void set_async(const std::optional<UnionAsync> & value) { this->async = value; }
+
+        const std::optional<UnionAtomic> & get_atomic() const { return atomic; }
+        std::optional<UnionAtomic> & get_mutable_atomic() { return atomic; }
+        void set_atomic(const std::optional<UnionAtomic> & value) { this->atomic = value; }
+
+        const std::optional<UnionAtomicCancel> & get_top_level_atomic_cancel() const { return top_level_atomic_cancel; }
+        std::optional<UnionAtomicCancel> & get_mutable_top_level_atomic_cancel() { return top_level_atomic_cancel; }
+        void set_top_level_atomic_cancel(const std::optional<UnionAtomicCancel> & value) { this->top_level_atomic_cancel = value; }
+
+        const std::optional<UnionAtomicCommit> & get_top_level_atomic_commit() const { return top_level_atomic_commit; }
+        std::optional<UnionAtomicCommit> & get_mutable_top_level_atomic_commit() { return top_level_atomic_commit; }
+        void set_top_level_atomic_commit(const std::optional<UnionAtomicCommit> & value) { this->top_level_atomic_commit = value; }
+
+        const std::optional<UnionAtomicNoexcept> & get_top_level_atomic_noexcept() const { return top_level_atomic_noexcept; }
+        std::optional<UnionAtomicNoexcept> & get_mutable_top_level_atomic_noexcept() { return top_level_atomic_noexcept; }
+        void set_top_level_atomic_noexcept(const std::optional<UnionAtomicNoexcept> & value) { this->top_level_atomic_noexcept = value; }
+
+        const std::optional<UnionAuto> & get_top_level_auto() const { return top_level_auto; }
+        std::optional<UnionAuto> & get_mutable_top_level_auto() { return top_level_auto; }
+        void set_top_level_auto(const std::optional<UnionAuto> & value) { this->top_level_auto = value; }
+
+        const std::optional<UnionAwait> & get_await() const { return await; }
+        std::optional<UnionAwait> & get_mutable_await() { return await; }
+        void set_await(const std::optional<UnionAwait> & value) { this->await = value; }
+
+        const std::optional<UnionBase> & get_base() const { return base; }
+        std::optional<UnionBase> & get_mutable_base() { return base; }
+        void set_base(const std::optional<UnionBase> & value) { this->base = value; }
+
+        const std::optional<UnionBitand> & get_top_level_bitand() const { return top_level_bitand; }
+        std::optional<UnionBitand> & get_mutable_top_level_bitand() { return top_level_bitand; }
+        void set_top_level_bitand(const std::optional<UnionBitand> & value) { this->top_level_bitand = value; }
+
+        const std::optional<UnionBitor> & get_top_level_bitor() const { return top_level_bitor; }
+        std::optional<UnionBitor> & get_mutable_top_level_bitor() { return top_level_bitor; }
+        void set_top_level_bitor(const std::optional<UnionBitor> & value) { this->top_level_bitor = value; }
+
+        const std::optional<UnionBool> & get_top_level_bool() const { return top_level_bool; }
+        std::optional<UnionBool> & get_mutable_top_level_bool() { return top_level_bool; }
+        void set_top_level_bool(const std::optional<UnionBool> & value) { this->top_level_bool = value; }
+
+        const std::optional<TopLevelUnionBool> & get_fluffy_bool() const { return fluffy_bool; }
+        std::optional<TopLevelUnionBool> & get_mutable_fluffy_bool() { return fluffy_bool; }
+        void set_fluffy_bool(const std::optional<TopLevelUnionBool> & value) { this->fluffy_bool = value; }
+
+        const std::optional<UnionBoolean> & get_boolean() const { return boolean; }
+        std::optional<UnionBoolean> & get_mutable_boolean() { return boolean; }
+        void set_boolean(const std::optional<UnionBoolean> & value) { this->boolean = value; }
+
+        const std::optional<UnionBreak> & get_top_level_break() const { return top_level_break; }
+        std::optional<UnionBreak> & get_mutable_top_level_break() { return top_level_break; }
+        void set_top_level_break(const std::optional<UnionBreak> & value) { this->top_level_break = value; }
+
+        const std::optional<UnionBycopy> & get_bycopy() const { return bycopy; }
+        std::optional<UnionBycopy> & get_mutable_bycopy() { return bycopy; }
+        void set_bycopy(const std::optional<UnionBycopy> & value) { this->bycopy = value; }
+
+        const std::optional<UnionByref> & get_byref() const { return byref; }
+        std::optional<UnionByref> & get_mutable_byref() { return byref; }
+        void set_byref(const std::optional<UnionByref> & value) { this->byref = value; }
+
+        const std::optional<UnionByte> & get_byte() const { return byte; }
+        std::optional<UnionByte> & get_mutable_byte() { return byte; }
+        void set_byte(const std::optional<UnionByte> & value) { this->byte = value; }
+
+        const std::optional<UnionCase> & get_top_level_case() const { return top_level_case; }
+        std::optional<UnionCase> & get_mutable_top_level_case() { return top_level_case; }
+        void set_top_level_case(const std::optional<UnionCase> & value) { this->top_level_case = value; }
+
+        const std::optional<UnionCatch> & get_top_level_catch() const { return top_level_catch; }
+        std::optional<UnionCatch> & get_mutable_top_level_catch() { return top_level_catch; }
+        void set_top_level_catch(const std::optional<UnionCatch> & value) { this->top_level_catch = value; }
+
+        const std::optional<UnionChan> & get_chan() const { return chan; }
+        std::optional<UnionChan> & get_mutable_chan() { return chan; }
+        void set_chan(const std::optional<UnionChan> & value) { this->chan = value; }
+
+        const std::optional<UnionChar> & get_top_level_char() const { return top_level_char; }
+        std::optional<UnionChar> & get_mutable_top_level_char() { return top_level_char; }
+        void set_top_level_char(const std::optional<UnionChar> & value) { this->top_level_char = value; }
+
+        const std::optional<UnionChar16T> & get_top_level_char16_t() const { return top_level_char16_t; }
+        std::optional<UnionChar16T> & get_mutable_top_level_char16_t() { return top_level_char16_t; }
+        void set_top_level_char16_t(const std::optional<UnionChar16T> & value) { this->top_level_char16_t = value; }
+
+        const std::optional<UnionChar32T> & get_top_level_char32_t() const { return top_level_char32_t; }
+        std::optional<UnionChar32T> & get_mutable_top_level_char32_t() { return top_level_char32_t; }
+        void set_top_level_char32_t(const std::optional<UnionChar32T> & value) { this->top_level_char32_t = value; }
+
+        const std::optional<UnionChecked> & get_checked() const { return checked; }
+        std::optional<UnionChecked> & get_mutable_checked() { return checked; }
+        void set_checked(const std::optional<UnionChecked> & value) { this->checked = value; }
+
+        const std::optional<UnionClassUnion> & get_purple_class() const { return purple_class; }
+        std::optional<UnionClassUnion> & get_mutable_purple_class() { return purple_class; }
+        void set_purple_class(const std::optional<UnionClassUnion> & value) { this->purple_class = value; }
+
+        const std::optional<UnionClass> & get_top_level_class() const { return top_level_class; }
+        std::optional<UnionClass> & get_mutable_top_level_class() { return top_level_class; }
+        void set_top_level_class(const std::optional<UnionClass> & value) { this->top_level_class = value; }
+
+        const std::optional<UnionCoAwait> & get_top_level_co_await() const { return top_level_co_await; }
+        std::optional<UnionCoAwait> & get_mutable_top_level_co_await() { return top_level_co_await; }
+        void set_top_level_co_await(const std::optional<UnionCoAwait> & value) { this->top_level_co_await = value; }
+
+        const std::optional<UnionCoReturn> & get_top_level_co_return() const { return top_level_co_return; }
+        std::optional<UnionCoReturn> & get_mutable_top_level_co_return() { return top_level_co_return; }
+        void set_top_level_co_return(const std::optional<UnionCoReturn> & value) { this->top_level_co_return = value; }
+
+        const std::optional<UnionCoYield> & get_top_level_co_yield() const { return top_level_co_yield; }
+        std::optional<UnionCoYield> & get_mutable_top_level_co_yield() { return top_level_co_yield; }
+        void set_top_level_co_yield(const std::optional<UnionCoYield> & value) { this->top_level_co_yield = value; }
+
+        const std::optional<UnionCompl> & get_top_level_compl() const { return top_level_compl; }
+        std::optional<UnionCompl> & get_mutable_top_level_compl() { return top_level_compl; }
+        void set_top_level_compl(const std::optional<UnionCompl> & value) { this->top_level_compl = value; }
+
+        const std::optional<UnionConcept> & get_top_level_concept() const { return top_level_concept; }
+        std::optional<UnionConcept> & get_mutable_top_level_concept() { return top_level_concept; }
+        void set_top_level_concept(const std::optional<UnionConcept> & value) { this->top_level_concept = value; }
+
+        const std::optional<UnionConsole> & get_console() const { return console; }
+        std::optional<UnionConsole> & get_mutable_console() { return console; }
+        void set_console(const std::optional<UnionConsole> & value) { this->console = value; }
+
+        const std::optional<UnionConst> & get_top_level_const() const { return top_level_const; }
+        std::optional<UnionConst> & get_mutable_top_level_const() { return top_level_const; }
+        void set_top_level_const(const std::optional<UnionConst> & value) { this->top_level_const = value; }
+
+        const std::optional<UnionConstCast> & get_top_level_const_cast() const { return top_level_const_cast; }
+        std::optional<UnionConstCast> & get_mutable_top_level_const_cast() { return top_level_const_cast; }
+        void set_top_level_const_cast(const std::optional<UnionConstCast> & value) { this->top_level_const_cast = value; }
+
+        const std::optional<UnionConstexpr> & get_top_level_constexpr() const { return top_level_constexpr; }
+        std::optional<UnionConstexpr> & get_mutable_top_level_constexpr() { return top_level_constexpr; }
+        void set_top_level_constexpr(const std::optional<UnionConstexpr> & value) { this->top_level_constexpr = value; }
+
+        const std::optional<UnionConstructor> & get_constructor() const { return constructor; }
+        std::optional<UnionConstructor> & get_mutable_constructor() { return constructor; }
+        void set_constructor(const std::optional<UnionConstructor> & value) { this->constructor = value; }
+
+        const std::optional<UnionContinue> & get_top_level_continue() const { return top_level_continue; }
+        std::optional<UnionContinue> & get_mutable_top_level_continue() { return top_level_continue; }
+        void set_top_level_continue(const std::optional<UnionContinue> & value) { this->top_level_continue = value; }
+
+        const std::optional<UnionConvenience> & get_convenience() const { return convenience; }
+        std::optional<UnionConvenience> & get_mutable_convenience() { return convenience; }
+        void set_convenience(const std::optional<UnionConvenience> & value) { this->convenience = value; }
+
+        const std::optional<UnionConvert> & get_convert() const { return convert; }
+        std::optional<UnionConvert> & get_mutable_convert() { return convert; }
+        void set_convert(const std::optional<UnionConvert> & value) { this->convert = value; }
+
+        const std::optional<UnionConverter> & get_converter() const { return converter; }
+        std::optional<UnionConverter> & get_mutable_converter() { return converter; }
+        void set_converter(const std::optional<UnionConverter> & value) { this->converter = value; }
+
+        const std::optional<UnionDate> & get_date() const { return date; }
+        std::optional<UnionDate> & get_mutable_date() { return date; }
+        void set_date(const std::optional<UnionDate> & value) { this->date = value; }
+
+        const std::optional<UnionDateParseHandling> & get_date_parse_handling() const { return date_parse_handling; }
+        std::optional<UnionDateParseHandling> & get_mutable_date_parse_handling() { return date_parse_handling; }
+        void set_date_parse_handling(const std::optional<UnionDateParseHandling> & value) { this->date_parse_handling = value; }
+
+        const std::optional<UnionDebugger> & get_debugger() const { return debugger; }
+        std::optional<UnionDebugger> & get_mutable_debugger() { return debugger; }
+        void set_debugger(const std::optional<UnionDebugger> & value) { this->debugger = value; }
+
+        const std::optional<UnionDecimal> & get_decimal() const { return decimal; }
+        std::optional<UnionDecimal> & get_mutable_decimal() { return decimal; }
+        void set_decimal(const std::optional<UnionDecimal> & value) { this->decimal = value; }
+
+        const std::optional<UnionDeclare> & get_declare() const { return declare; }
+        std::optional<UnionDeclare> & get_mutable_declare() { return declare; }
+        void set_declare(const std::optional<UnionDeclare> & value) { this->declare = value; }
+
+        const std::optional<UnionDecltype> & get_top_level_decltype() const { return top_level_decltype; }
+        std::optional<UnionDecltype> & get_mutable_top_level_decltype() { return top_level_decltype; }
+        void set_top_level_decltype(const std::optional<UnionDecltype> & value) { this->top_level_decltype = value; }
+
+        const std::optional<UnionDecodeString> & get_decode_string() const { return decode_string; }
+        std::optional<UnionDecodeString> & get_mutable_decode_string() { return decode_string; }
+        void set_decode_string(const std::optional<UnionDecodeString> & value) { this->decode_string = value; }
+
+        const std::optional<UnionDef> & get_def() const { return def; }
+        std::optional<UnionDef> & get_mutable_def() { return def; }
+        void set_def(const std::optional<UnionDef> & value) { this->def = value; }
+
+        const std::optional<UnionDefault> & get_top_level_default() const { return top_level_default; }
+        std::optional<UnionDefault> & get_mutable_top_level_default() { return top_level_default; }
+        void set_top_level_default(const std::optional<UnionDefault> & value) { this->top_level_default = value; }
+
+        const std::optional<UnionDefer> & get_defer() const { return defer; }
+        std::optional<UnionDefer> & get_mutable_defer() { return defer; }
+        void set_defer(const std::optional<UnionDefer> & value) { this->defer = value; }
+
+        const std::optional<UnionDeinit> & get_deinit() const { return deinit; }
+        std::optional<UnionDeinit> & get_mutable_deinit() { return deinit; }
+        void set_deinit(const std::optional<UnionDeinit> & value) { this->deinit = value; }
+
+        const std::optional<UnionDel> & get_del() const { return del; }
+        std::optional<UnionDel> & get_mutable_del() { return del; }
+        void set_del(const std::optional<UnionDel> & value) { this->del = value; }
+
+        const std::optional<UnionDelegate> & get_delegate() const { return delegate; }
+        std::optional<UnionDelegate> & get_mutable_delegate() { return delegate; }
+        void set_delegate(const std::optional<UnionDelegate> & value) { this->delegate = value; }
+
+        const std::optional<UnionDelete> & get_top_level_delete() const { return top_level_delete; }
+        std::optional<UnionDelete> & get_mutable_top_level_delete() { return top_level_delete; }
+        void set_top_level_delete(const std::optional<UnionDelete> & value) { this->top_level_delete = value; }
+
+        const std::optional<UnionDict> & get_dict() const { return dict; }
+        std::optional<UnionDict> & get_mutable_dict() { return dict; }
+        void set_dict(const std::optional<UnionDict> & value) { this->dict = value; }
+
+        const std::optional<UnionDictionary> & get_dictionary() const { return dictionary; }
+        std::optional<UnionDictionary> & get_mutable_dictionary() { return dictionary; }
+        void set_dictionary(const std::optional<UnionDictionary> & value) { this->dictionary = value; }
+
+        const std::optional<UnionDidSet> & get_did_set() const { return did_set; }
+        std::optional<UnionDidSet> & get_mutable_did_set() { return did_set; }
+        void set_did_set(const std::optional<UnionDidSet> & value) { this->did_set = value; }
+
+        const std::optional<UnionDo> & get_top_level_do() const { return top_level_do; }
+        std::optional<UnionDo> & get_mutable_top_level_do() { return top_level_do; }
+        void set_top_level_do(const std::optional<UnionDo> & value) { this->top_level_do = value; }
+
+        const std::optional<UnionDouble> & get_top_level_double() const { return top_level_double; }
+        std::optional<UnionDouble> & get_mutable_top_level_double() { return top_level_double; }
+        void set_top_level_double(const std::optional<UnionDouble> & value) { this->top_level_double = value; }
+
+        const std::optional<double> & get_dummy() const { return dummy; }
+        std::optional<double> & get_mutable_dummy() { return dummy; }
+        void set_dummy(const std::optional<double> & value) { this->dummy = value; }
+
+        const std::optional<UnionDynamic> & get_dynamic() const { return dynamic; }
+        std::optional<UnionDynamic> & get_mutable_dynamic() { return dynamic; }
+        void set_dynamic(const std::optional<UnionDynamic> & value) { this->dynamic = value; }
+
+        const std::optional<UnionDynamicCast> & get_top_level_dynamic_cast() const { return top_level_dynamic_cast; }
+        std::optional<UnionDynamicCast> & get_mutable_top_level_dynamic_cast() { return top_level_dynamic_cast; }
+        void set_top_level_dynamic_cast(const std::optional<UnionDynamicCast> & value) { this->top_level_dynamic_cast = value; }
+
+        const std::optional<UnionElif> & get_elif() const { return elif; }
+        std::optional<UnionElif> & get_mutable_elif() { return elif; }
+        void set_elif(const std::optional<UnionElif> & value) { this->elif = value; }
+
+        const std::optional<UnionElse> & get_top_level_else() const { return top_level_else; }
+        std::optional<UnionElse> & get_mutable_top_level_else() { return top_level_else; }
+        void set_top_level_else(const std::optional<UnionElse> & value) { this->top_level_else = value; }
+
+        const std::optional<UnionEncodeQuickType> & get_encode_quick_type() const { return encode_quick_type; }
+        std::optional<UnionEncodeQuickType> & get_mutable_encode_quick_type() { return encode_quick_type; }
+        void set_encode_quick_type(const std::optional<UnionEncodeQuickType> & value) { this->encode_quick_type = value; }
+
+        const std::optional<UnionEnum> & get_top_level_enum() const { return top_level_enum; }
+        std::optional<UnionEnum> & get_mutable_top_level_enum() { return top_level_enum; }
+        void set_top_level_enum(const std::optional<UnionEnum> & value) { this->top_level_enum = value; }
+
+        const std::optional<UnionEvent> & get_event() const { return event; }
+        std::optional<UnionEvent> & get_mutable_event() { return event; }
+        void set_event(const std::optional<UnionEvent> & value) { this->event = value; }
+
+        const std::optional<UnionExcept> & get_except() const { return except; }
+        std::optional<UnionExcept> & get_mutable_except() { return except; }
+        void set_except(const std::optional<UnionExcept> & value) { this->except = value; }
+
+        const std::optional<UnionException> & get_exception() const { return exception; }
+        std::optional<UnionException> & get_mutable_exception() { return exception; }
+        void set_exception(const std::optional<UnionException> & value) { this->exception = value; }
+
+        const std::optional<UnionExplicit> & get_top_level_explicit() const { return top_level_explicit; }
+        std::optional<UnionExplicit> & get_mutable_top_level_explicit() { return top_level_explicit; }
+        void set_top_level_explicit(const std::optional<UnionExplicit> & value) { this->top_level_explicit = value; }
+
+        const std::optional<UnionExport> & get_top_level_export() const { return top_level_export; }
+        std::optional<UnionExport> & get_mutable_top_level_export() { return top_level_export; }
+        void set_top_level_export(const std::optional<UnionExport> & value) { this->top_level_export = value; }
+
+        const std::optional<UnionExposing> & get_exposing() const { return exposing; }
+        std::optional<UnionExposing> & get_mutable_exposing() { return exposing; }
+        void set_exposing(const std::optional<UnionExposing> & value) { this->exposing = value; }
+
+        const std::optional<UnionExtends> & get_extends() const { return extends; }
+        std::optional<UnionExtends> & get_mutable_extends() { return extends; }
+        void set_extends(const std::optional<UnionExtends> & value) { this->extends = value; }
+
+        const std::optional<UnionExtension> & get_extension() const { return extension; }
+        std::optional<UnionExtension> & get_mutable_extension() { return extension; }
+        void set_extension(const std::optional<UnionExtension> & value) { this->extension = value; }
+
+        const std::optional<UnionExtern> & get_top_level_extern() const { return top_level_extern; }
+        std::optional<UnionExtern> & get_mutable_top_level_extern() { return top_level_extern; }
+        void set_top_level_extern(const std::optional<UnionExtern> & value) { this->top_level_extern = value; }
+
+        const std::optional<UnionFallthrough> & get_fallthrough() const { return fallthrough; }
+        std::optional<UnionFallthrough> & get_mutable_fallthrough() { return fallthrough; }
+        void set_fallthrough(const std::optional<UnionFallthrough> & value) { this->fallthrough = value; }
+
+        const std::optional<UnionFalseUnion> & get_purple_false() const { return purple_false; }
+        std::optional<UnionFalseUnion> & get_mutable_purple_false() { return purple_false; }
+        void set_purple_false(const std::optional<UnionFalseUnion> & value) { this->purple_false = value; }
+
+        const std::optional<UnionFalse> & get_top_level_false() const { return top_level_false; }
+        std::optional<UnionFalse> & get_mutable_top_level_false() { return top_level_false; }
+        void set_top_level_false(const std::optional<UnionFalse> & value) { this->top_level_false = value; }
+
+        const std::optional<UnionFileprivate> & get_fileprivate() const { return fileprivate; }
+        std::optional<UnionFileprivate> & get_mutable_fileprivate() { return fileprivate; }
+        void set_fileprivate(const std::optional<UnionFileprivate> & value) { this->fileprivate = value; }
+
+        const std::optional<UnionFinal> & get_top_level_final() const { return top_level_final; }
+        std::optional<UnionFinal> & get_mutable_top_level_final() { return top_level_final; }
+        void set_top_level_final(const std::optional<UnionFinal> & value) { this->top_level_final = value; }
+
+        const std::optional<UnionFinally> & get_finally() const { return finally; }
+        std::optional<UnionFinally> & get_mutable_finally() { return finally; }
+        void set_finally(const std::optional<UnionFinally> & value) { this->finally = value; }
+
+        const std::optional<UnionFixed> & get_fixed() const { return fixed; }
+        std::optional<UnionFixed> & get_mutable_fixed() { return fixed; }
+        void set_fixed(const std::optional<UnionFixed> & value) { this->fixed = value; }
+
+        const std::optional<UnionFloat> & get_top_level_float() const { return top_level_float; }
+        std::optional<UnionFloat> & get_mutable_top_level_float() { return top_level_float; }
+        void set_top_level_float(const std::optional<UnionFloat> & value) { this->top_level_float = value; }
+
+        const std::optional<UnionFor> & get_top_level_for() const { return top_level_for; }
+        std::optional<UnionFor> & get_mutable_top_level_for() { return top_level_for; }
+        void set_top_level_for(const std::optional<UnionFor> & value) { this->top_level_for = value; }
+
+        const std::optional<UnionForeach> & get_foreach() const { return foreach; }
+        std::optional<UnionForeach> & get_mutable_foreach() { return foreach; }
+        void set_foreach(const std::optional<UnionForeach> & value) { this->foreach = value; }
+
+        const std::optional<UnionFriend> & get_top_level_friend() const { return top_level_friend; }
+        std::optional<UnionFriend> & get_mutable_top_level_friend() { return top_level_friend; }
+        void set_top_level_friend(const std::optional<UnionFriend> & value) { this->top_level_friend = value; }
+
+        const std::optional<UnionFrom> & get_from() const { return from; }
+        std::optional<UnionFrom> & get_mutable_from() { return from; }
+        void set_from(const std::optional<UnionFrom> & value) { this->from = value; }
+
+        const std::optional<UnionFromJson> & get_from_json() const { return from_json; }
+        std::optional<UnionFromJson> & get_mutable_from_json() { return from_json; }
+        void set_from_json(const std::optional<UnionFromJson> & value) { this->from_json = value; }
+
+        const std::optional<UnionFunc> & get_func() const { return func; }
+        std::optional<UnionFunc> & get_mutable_func() { return func; }
+        void set_func(const std::optional<UnionFunc> & value) { this->func = value; }
+
+        const std::optional<UnionFunction> & get_function() const { return function; }
+        std::optional<UnionFunction> & get_mutable_function() { return function; }
+        void set_function(const std::optional<UnionFunction> & value) { this->function = value; }
+
+        const std::optional<UnionGet> & get_get() const { return get; }
+        std::optional<UnionGet> & get_mutable_get() { return get; }
+        void set_get(const std::optional<UnionGet> & value) { this->get = value; }
+
+        const std::optional<UnionGlobal> & get_global() const { return global; }
+        std::optional<UnionGlobal> & get_mutable_global() { return global; }
+        void set_global(const std::optional<UnionGlobal> & value) { this->global = value; }
+
+        const std::optional<UnionGo> & get_go() const { return go; }
+        std::optional<UnionGo> & get_mutable_go() { return go; }
+        void set_go(const std::optional<UnionGo> & value) { this->go = value; }
+
+        const std::optional<UnionGoto> & get_top_level_goto() const { return top_level_goto; }
+        std::optional<UnionGoto> & get_mutable_top_level_goto() { return top_level_goto; }
+        void set_top_level_goto(const std::optional<UnionGoto> & value) { this->top_level_goto = value; }
+
+        const std::optional<UnionGuard> & get_guard() const { return guard; }
+        std::optional<UnionGuard> & get_mutable_guard() { return guard; }
+        void set_guard(const std::optional<UnionGuard> & value) { this->guard = value; }
+
+        const std::optional<UnionHasOwnProperty> & get_has_own_property() const { return has_own_property; }
+        std::optional<UnionHasOwnProperty> & get_mutable_has_own_property() { return has_own_property; }
+        void set_has_own_property(const std::optional<UnionHasOwnProperty> & value) { this->has_own_property = value; }
+
+        const std::optional<UnionId> & get_id() const { return id; }
+        std::optional<UnionId> & get_mutable_id() { return id; }
+        void set_id(const std::optional<UnionId> & value) { this->id = value; }
+
+        const std::optional<UnionIf> & get_top_level_if() const { return top_level_if; }
+        std::optional<UnionIf> & get_mutable_top_level_if() { return top_level_if; }
+        void set_top_level_if(const std::optional<UnionIf> & value) { this->top_level_if = value; }
+
+        const std::optional<UnionImp> & get_imp() const { return imp; }
+        std::optional<UnionImp> & get_mutable_imp() { return imp; }
+        void set_imp(const std::optional<UnionImp> & value) { this->imp = value; }
+
+        const std::optional<UnionImplements> & get_implements() const { return implements; }
+        std::optional<UnionImplements> & get_mutable_implements() { return implements; }
+        void set_implements(const std::optional<UnionImplements> & value) { this->implements = value; }
+
+        const std::optional<UnionImplicit> & get_implicit() const { return implicit; }
+        std::optional<UnionImplicit> & get_mutable_implicit() { return implicit; }
+        void set_implicit(const std::optional<UnionImplicit> & value) { this->implicit = value; }
+
+        const std::optional<UnionImport> & get_top_level_import() const { return top_level_import; }
+        std::optional<UnionImport> & get_mutable_top_level_import() { return top_level_import; }
+        void set_top_level_import(const std::optional<UnionImport> & value) { this->top_level_import = value; }
+
+        const std::optional<UnionIn> & get_in() const { return in; }
+        std::optional<UnionIn> & get_mutable_in() { return in; }
+        void set_in(const std::optional<UnionIn> & value) { this->in = value; }
+
+        const std::optional<UnionIndirect> & get_indirect() const { return indirect; }
+        std::optional<UnionIndirect> & get_mutable_indirect() { return indirect; }
+        void set_indirect(const std::optional<UnionIndirect> & value) { this->indirect = value; }
+
+        const std::optional<UnionInfix> & get_infix() const { return infix; }
+        std::optional<UnionInfix> & get_mutable_infix() { return infix; }
+        void set_infix(const std::optional<UnionInfix> & value) { this->infix = value; }
+
+        const std::optional<UnionInit> & get_init() const { return init; }
+        std::optional<UnionInit> & get_mutable_init() { return init; }
+        void set_init(const std::optional<UnionInit> & value) { this->init = value; }
+
+        const std::optional<UnionInline> & get_top_level_inline() const { return top_level_inline; }
+        std::optional<UnionInline> & get_mutable_top_level_inline() { return top_level_inline; }
+        void set_top_level_inline(const std::optional<UnionInline> & value) { this->top_level_inline = value; }
+
+        const std::optional<UnionInout> & get_inout() const { return inout; }
+        std::optional<UnionInout> & get_mutable_inout() { return inout; }
+        void set_inout(const std::optional<UnionInout> & value) { this->inout = value; }
+
+        const std::optional<UnionInstanceof> & get_instanceof() const { return instanceof; }
+        std::optional<UnionInstanceof> & get_mutable_instanceof() { return instanceof; }
+        void set_instanceof(const std::optional<UnionInstanceof> & value) { this->instanceof = value; }
+
+        const std::optional<UnionInt> & get_top_level_int() const { return top_level_int; }
+        std::optional<UnionInt> & get_mutable_top_level_int() { return top_level_int; }
+        void set_top_level_int(const std::optional<UnionInt> & value) { this->top_level_int = value; }
+
+        const std::optional<UnionInterface> & get_interface() const { return interface; }
+        std::optional<UnionInterface> & get_mutable_interface() { return interface; }
+        void set_interface(const std::optional<UnionInterface> & value) { this->interface = value; }
+
+        const std::optional<UnionInternal> & get_internal() const { return internal; }
+        std::optional<UnionInternal> & get_mutable_internal() { return internal; }
+        void set_internal(const std::optional<UnionInternal> & value) { this->internal = value; }
+
+        const std::optional<UnionIs> & get_is() const { return is; }
+        std::optional<UnionIs> & get_mutable_is() { return is; }
+        void set_is(const std::optional<UnionIs> & value) { this->is = value; }
+
+        const std::optional<UnionIterable> & get_iterable() const { return iterable; }
+        std::optional<UnionIterable> & get_mutable_iterable() { return iterable; }
+        void set_iterable(const std::optional<UnionIterable> & value) { this->iterable = value; }
+
+        const std::optional<UnionJdec> & get_jdec() const { return jdec; }
+        std::optional<UnionJdec> & get_mutable_jdec() { return jdec; }
+        void set_jdec(const std::optional<UnionJdec> & value) { this->jdec = value; }
+
+        const std::optional<UnionJenc> & get_jenc() const { return jenc; }
+        std::optional<UnionJenc> & get_mutable_jenc() { return jenc; }
+        void set_jenc(const std::optional<UnionJenc> & value) { this->jenc = value; }
+
+        const std::optional<UnionJpipe> & get_jpipe() const { return jpipe; }
+        std::optional<UnionJpipe> & get_mutable_jpipe() { return jpipe; }
+        void set_jpipe(const std::optional<UnionJpipe> & value) { this->jpipe = value; }
+
+        const std::optional<UnionJson> & get_json() const { return json; }
+        std::optional<UnionJson> & get_mutable_json() { return json; }
+        void set_json(const std::optional<UnionJson> & value) { this->json = value; }
+
+        const std::optional<UnionJsonConverter> & get_json_converter() const { return json_converter; }
+        std::optional<UnionJsonConverter> & get_mutable_json_converter() { return json_converter; }
+        void set_json_converter(const std::optional<UnionJsonConverter> & value) { this->json_converter = value; }
+
+        const std::optional<UnionJsonSerializer> & get_json_serializer() const { return json_serializer; }
+        std::optional<UnionJsonSerializer> & get_mutable_json_serializer() { return json_serializer; }
+        void set_json_serializer(const std::optional<UnionJsonSerializer> & value) { this->json_serializer = value; }
+
+        const std::optional<UnionJsonToken> & get_json_token() const { return json_token; }
+        std::optional<UnionJsonToken> & get_mutable_json_token() { return json_token; }
+        void set_json_token(const std::optional<UnionJsonToken> & value) { this->json_token = value; }
+
+        const std::optional<UnionJsonWriter> & get_json_writer() const { return json_writer; }
+        std::optional<UnionJsonWriter> & get_mutable_json_writer() { return json_writer; }
+        void set_json_writer(const std::optional<UnionJsonWriter> & value) { this->json_writer = value; }
+
+        const std::optional<UnionLambda> & get_lambda() const { return lambda; }
+        std::optional<UnionLambda> & get_mutable_lambda() { return lambda; }
+        void set_lambda(const std::optional<UnionLambda> & value) { this->lambda = value; }
+
+        const std::optional<UnionLazy> & get_lazy() const { return lazy; }
+        std::optional<UnionLazy> & get_mutable_lazy() { return lazy; }
+        void set_lazy(const std::optional<UnionLazy> & value) { this->lazy = value; }
+
+        const std::optional<UnionLeft> & get_left() const { return left; }
+        std::optional<UnionLeft> & get_mutable_left() { return left; }
+        void set_left(const std::optional<UnionLeft> & value) { this->left = value; }
+
+        const std::optional<UnionLet> & get_let() const { return let; }
+        std::optional<UnionLet> & get_mutable_let() { return let; }
+        void set_let(const std::optional<UnionLet> & value) { this->let = value; }
+
+        const std::optional<UnionList> & get_list() const { return list; }
+        std::optional<UnionList> & get_mutable_list() { return list; }
+        void set_list(const std::optional<UnionList> & value) { this->list = value; }
+
+        const std::optional<UnionLock> & get_lock() const { return lock; }
+        std::optional<UnionLock> & get_mutable_lock() { return lock; }
+        void set_lock(const std::optional<UnionLock> & value) { this->lock = value; }
+
+        const std::optional<UnionLong> & get_top_level_long() const { return top_level_long; }
+        std::optional<UnionLong> & get_mutable_top_level_long() { return top_level_long; }
+        void set_top_level_long(const std::optional<UnionLong> & value) { this->top_level_long = value; }
+
+        const std::optional<UnionMap> & get_map() const { return map; }
+        std::optional<UnionMap> & get_mutable_map() { return map; }
+        void set_map(const std::optional<UnionMap> & value) { this->map = value; }
+
+        const std::optional<UnionMetadataPropertyHandling> & get_metadata_property_handling() const { return metadata_property_handling; }
+        std::optional<UnionMetadataPropertyHandling> & get_mutable_metadata_property_handling() { return metadata_property_handling; }
+        void set_metadata_property_handling(const std::optional<UnionMetadataPropertyHandling> & value) { this->metadata_property_handling = value; }
+
+        const std::optional<UnionModule> & get_top_level_module() const { return top_level_module; }
+        std::optional<UnionModule> & get_mutable_top_level_module() { return top_level_module; }
+        void set_top_level_module(const std::optional<UnionModule> & value) { this->top_level_module = value; }
+
+        const std::optional<UnionMutable> & get_top_level_mutable() const { return top_level_mutable; }
+        std::optional<UnionMutable> & get_mutable_top_level_mutable() { return top_level_mutable; }
+        void set_top_level_mutable(const std::optional<UnionMutable> & value) { this->top_level_mutable = value; }
+
+        const std::optional<UnionMutating> & get_mutating() const { return mutating; }
+        std::optional<UnionMutating> & get_mutable_mutating() { return mutating; }
+        void set_mutating(const std::optional<UnionMutating> & value) { this->mutating = value; }
+
+        const std::optional<UnionNamespace> & get_top_level_namespace() const { return top_level_namespace; }
+        std::optional<UnionNamespace> & get_mutable_top_level_namespace() { return top_level_namespace; }
+        void set_top_level_namespace(const std::optional<UnionNamespace> & value) { this->top_level_namespace = value; }
+
+        const std::optional<UnionNative> & get_native() const { return native; }
+        std::optional<UnionNative> & get_mutable_native() { return native; }
+        void set_native(const std::optional<UnionNative> & value) { this->native = value; }
+
+        const std::optional<UnionNew> & get_top_level_new() const { return top_level_new; }
+        std::optional<UnionNew> & get_mutable_top_level_new() { return top_level_new; }
+        void set_top_level_new(const std::optional<UnionNew> & value) { this->top_level_new = value; }
+
+        const std::optional<UnionNewtonsoft> & get_newtonsoft() const { return newtonsoft; }
+        std::optional<UnionNewtonsoft> & get_mutable_newtonsoft() { return newtonsoft; }
+        void set_newtonsoft(const std::optional<UnionNewtonsoft> & value) { this->newtonsoft = value; }
+
+        const std::optional<UnionNil> & get_nil() const { return nil; }
+        std::optional<UnionNil> & get_mutable_nil() { return nil; }
+        void set_nil(const std::optional<UnionNil> & value) { this->nil = value; }
+
+        const std::optional<UnionNo> & get_no() const { return no; }
+        std::optional<UnionNo> & get_mutable_no() { return no; }
+        void set_no(const std::optional<UnionNo> & value) { this->no = value; }
+
+        const std::optional<UnionNoexcept> & get_top_level_noexcept() const { return top_level_noexcept; }
+        std::optional<UnionNoexcept> & get_mutable_top_level_noexcept() { return top_level_noexcept; }
+        void set_top_level_noexcept(const std::optional<UnionNoexcept> & value) { this->top_level_noexcept = value; }
+
+        const std::optional<UnionNonatomic> & get_nonatomic() const { return nonatomic; }
+        std::optional<UnionNonatomic> & get_mutable_nonatomic() { return nonatomic; }
+        void set_nonatomic(const std::optional<UnionNonatomic> & value) { this->nonatomic = value; }
+
+        const std::optional<UnionNoneUnion> & get_top_level_none() const { return top_level_none; }
+        std::optional<UnionNoneUnion> & get_mutable_top_level_none() { return top_level_none; }
+        void set_top_level_none(const std::optional<UnionNoneUnion> & value) { this->top_level_none = value; }
+
+        const std::optional<UnionNone> & get_none() const { return none; }
+        std::optional<UnionNone> & get_mutable_none() { return none; }
+        void set_none(const std::optional<UnionNone> & value) { this->none = value; }
+
+        const std::optional<UnionNonlocal> & get_nonlocal() const { return nonlocal; }
+        std::optional<UnionNonlocal> & get_mutable_nonlocal() { return nonlocal; }
+        void set_nonlocal(const std::optional<UnionNonlocal> & value) { this->nonlocal = value; }
+
+        const std::optional<UnionNonmutating> & get_nonmutating() const { return nonmutating; }
+        std::optional<UnionNonmutating> & get_mutable_nonmutating() { return nonmutating; }
+        void set_nonmutating(const std::optional<UnionNonmutating> & value) { this->nonmutating = value; }
+
+        const std::optional<UnionNot> & get_top_level_not() const { return top_level_not; }
+        std::optional<UnionNot> & get_mutable_top_level_not() { return top_level_not; }
+        void set_top_level_not(const std::optional<UnionNot> & value) { this->top_level_not = value; }
+
+        const std::optional<UnionNotEq> & get_top_level_not_eq() const { return top_level_not_eq; }
+        std::optional<UnionNotEq> & get_mutable_top_level_not_eq() { return top_level_not_eq; }
+        void set_top_level_not_eq(const std::optional<UnionNotEq> & value) { this->top_level_not_eq = value; }
+
+        const std::optional<UnionNsString> & get_ns_string() const { return ns_string; }
+        std::optional<UnionNsString> & get_mutable_ns_string() { return ns_string; }
+        void set_ns_string(const std::optional<UnionNsString> & value) { this->ns_string = value; }
+
+        const std::optional<UnionNull> & get_null() const { return null; }
+        std::optional<UnionNull> & get_mutable_null() { return null; }
+        void set_null(const std::optional<UnionNull> & value) { this->null = value; }
+
+        const std::optional<UnionNullUnion> & get_top_level_null() const { return top_level_null; }
+        std::optional<UnionNullUnion> & get_mutable_top_level_null() { return top_level_null; }
+        void set_top_level_null(const std::optional<UnionNullUnion> & value) { this->top_level_null = value; }
+
+        const std::optional<UnionNullptr> & get_top_level_nullptr() const { return top_level_nullptr; }
+        std::optional<UnionNullptr> & get_mutable_top_level_nullptr() { return top_level_nullptr; }
+        void set_top_level_nullptr(const std::optional<UnionNullptr> & value) { this->top_level_nullptr = value; }
+
+        const std::optional<UnionNumber> & get_number() const { return number; }
+        std::optional<UnionNumber> & get_mutable_number() { return number; }
+        void set_number(const std::optional<UnionNumber> & value) { this->number = value; }
+
+        const std::optional<UnionObject> & get_object() const { return object; }
+        std::optional<UnionObject> & get_mutable_object() { return object; }
+        void set_object(const std::optional<UnionObject> & value) { this->object = value; }
+
+        const std::optional<UnionOf> & get_of() const { return of; }
+        std::optional<UnionOf> & get_mutable_of() { return of; }
+        void set_of(const std::optional<UnionOf> & value) { this->of = value; }
+
+        const std::optional<UnionOneway> & get_oneway() const { return oneway; }
+        std::optional<UnionOneway> & get_mutable_oneway() { return oneway; }
+        void set_oneway(const std::optional<UnionOneway> & value) { this->oneway = value; }
+
+        const std::optional<UnionOpen> & get_open() const { return open; }
+        std::optional<UnionOpen> & get_mutable_open() { return open; }
+        void set_open(const std::optional<UnionOpen> & value) { this->open = value; }
+
+        const std::optional<UnionOperator> & get_top_level_operator() const { return top_level_operator; }
+        std::optional<UnionOperator> & get_mutable_top_level_operator() { return top_level_operator; }
+        void set_top_level_operator(const std::optional<UnionOperator> & value) { this->top_level_operator = value; }
+
+        const std::optional<UnionOptional> & get_optional() const { return optional; }
+        std::optional<UnionOptional> & get_mutable_optional() { return optional; }
+        void set_optional(const std::optional<UnionOptional> & value) { this->optional = value; }
+
+        const std::optional<UnionOr> & get_top_level_or() const { return top_level_or; }
+        std::optional<UnionOr> & get_mutable_top_level_or() { return top_level_or; }
+        void set_top_level_or(const std::optional<UnionOr> & value) { this->top_level_or = value; }
+
+        const std::optional<UnionOrEq> & get_top_level_or_eq() const { return top_level_or_eq; }
+        std::optional<UnionOrEq> & get_mutable_top_level_or_eq() { return top_level_or_eq; }
+        void set_top_level_or_eq(const std::optional<UnionOrEq> & value) { this->top_level_or_eq = value; }
+
+        const std::optional<UnionOut> & get_out() const { return out; }
+        std::optional<UnionOut> & get_mutable_out() { return out; }
+        void set_out(const std::optional<UnionOut> & value) { this->out = value; }
+
+        const std::optional<UnionOverride> & get_top_level_override() const { return top_level_override; }
+        std::optional<UnionOverride> & get_mutable_top_level_override() { return top_level_override; }
+        void set_top_level_override(const std::optional<UnionOverride> & value) { this->top_level_override = value; }
+
+        const std::optional<UnionPackage> & get_package() const { return package; }
+        std::optional<UnionPackage> & get_mutable_package() { return package; }
+        void set_package(const std::optional<UnionPackage> & value) { this->package = value; }
+
+        const std::optional<UnionParams> & get_params() const { return params; }
+        std::optional<UnionParams> & get_mutable_params() { return params; }
+        void set_params(const std::optional<UnionParams> & value) { this->params = value; }
+
+        const std::optional<UnionPass> & get_pass() const { return pass; }
+        std::optional<UnionPass> & get_mutable_pass() { return pass; }
+        void set_pass(const std::optional<UnionPass> & value) { this->pass = value; }
+
+        const std::optional<UnionPort> & get_port() const { return port; }
+        std::optional<UnionPort> & get_mutable_port() { return port; }
+        void set_port(const std::optional<UnionPort> & value) { this->port = value; }
+
+        const std::optional<UnionPostfix> & get_postfix() const { return postfix; }
+        std::optional<UnionPostfix> & get_mutable_postfix() { return postfix; }
+        void set_postfix(const std::optional<UnionPostfix> & value) { this->postfix = value; }
+
+        const std::optional<UnionPrecedence> & get_precedence() const { return precedence; }
+        std::optional<UnionPrecedence> & get_mutable_precedence() { return precedence; }
+        void set_precedence(const std::optional<UnionPrecedence> & value) { this->precedence = value; }
+
+        const std::optional<UnionPrefix> & get_prefix() const { return prefix; }
+        std::optional<UnionPrefix> & get_mutable_prefix() { return prefix; }
+        void set_prefix(const std::optional<UnionPrefix> & value) { this->prefix = value; }
+
+        const std::optional<UnionPrint> & get_print() const { return print; }
+        std::optional<UnionPrint> & get_mutable_print() { return print; }
+        void set_print(const std::optional<UnionPrint> & value) { this->print = value; }
+
+        const std::optional<UnionPrintf> & get_printf() const { return printf; }
+        std::optional<UnionPrintf> & get_mutable_printf() { return printf; }
+        void set_printf(const std::optional<UnionPrintf> & value) { this->printf = value; }
+
+        const std::optional<UnionPrivate> & get_top_level_private() const { return top_level_private; }
+        std::optional<UnionPrivate> & get_mutable_top_level_private() { return top_level_private; }
+        void set_top_level_private(const std::optional<UnionPrivate> & value) { this->top_level_private = value; }
+
+        const std::optional<UnionProtected> & get_top_level_protected() const { return top_level_protected; }
+        std::optional<UnionProtected> & get_mutable_top_level_protected() { return top_level_protected; }
+        void set_top_level_protected(const std::optional<UnionProtected> & value) { this->top_level_protected = value; }
+
+        const std::optional<UnionProtocol> & get_protocol() const { return protocol; }
+        std::optional<UnionProtocol> & get_mutable_protocol() { return protocol; }
+        void set_protocol(const std::optional<UnionProtocol> & value) { this->protocol = value; }
+
+        const std::optional<UnionProtocolUnion> & get_top_level_protocol() const { return top_level_protocol; }
+        std::optional<UnionProtocolUnion> & get_mutable_top_level_protocol() { return top_level_protocol; }
+        void set_top_level_protocol(const std::optional<UnionProtocolUnion> & value) { this->top_level_protocol = value; }
+
+        const std::optional<UnionPublic> & get_top_level_public() const { return top_level_public; }
+        std::optional<UnionPublic> & get_mutable_top_level_public() { return top_level_public; }
+        void set_top_level_public(const std::optional<UnionPublic> & value) { this->top_level_public = value; }
+
+        const std::optional<UnionQuicktype> & get_quicktype() const { return quicktype; }
+        std::optional<UnionQuicktype> & get_mutable_quicktype() { return quicktype; }
+        void set_quicktype(const std::optional<UnionQuicktype> & value) { this->quicktype = value; }
+
+        const std::optional<UnionRaise> & get_raise() const { return raise; }
+        std::optional<UnionRaise> & get_mutable_raise() { return raise; }
+        void set_raise(const std::optional<UnionRaise> & value) { this->raise = value; }
+
+        const std::optional<UnionRange> & get_range() const { return range; }
+        std::optional<UnionRange> & get_mutable_range() { return range; }
+        void set_range(const std::optional<UnionRange> & value) { this->range = value; }
+
+        const std::optional<UnionReadonly> & get_readonly() const { return readonly; }
+        std::optional<UnionReadonly> & get_mutable_readonly() { return readonly; }
+        void set_readonly(const std::optional<UnionReadonly> & value) { this->readonly = value; }
+
+        const std::optional<UnionRef> & get_ref() const { return ref; }
+        std::optional<UnionRef> & get_mutable_ref() { return ref; }
+        void set_ref(const std::optional<UnionRef> & value) { this->ref = value; }
+
+        const std::optional<UnionRegister> & get_top_level_register() const { return top_level_register; }
+        std::optional<UnionRegister> & get_mutable_top_level_register() { return top_level_register; }
+        void set_top_level_register(const std::optional<UnionRegister> & value) { this->top_level_register = value; }
+
+        const std::optional<UnionReinterpretCast> & get_top_level_reinterpret_cast() const { return top_level_reinterpret_cast; }
+        std::optional<UnionReinterpretCast> & get_mutable_top_level_reinterpret_cast() { return top_level_reinterpret_cast; }
+        void set_top_level_reinterpret_cast(const std::optional<UnionReinterpretCast> & value) { this->top_level_reinterpret_cast = value; }
+
+        const std::optional<UnionRepeat> & get_repeat() const { return repeat; }
+        std::optional<UnionRepeat> & get_mutable_repeat() { return repeat; }
+        void set_repeat(const std::optional<UnionRepeat> & value) { this->repeat = value; }
+
+        const std::optional<UnionRequire> & get_require() const { return require; }
+        std::optional<UnionRequire> & get_mutable_require() { return require; }
+        void set_require(const std::optional<UnionRequire> & value) { this->require = value; }
+
+        const std::optional<UnionRequired> & get_required() const { return required; }
+        std::optional<UnionRequired> & get_mutable_required() { return required; }
+        void set_required(const std::optional<UnionRequired> & value) { this->required = value; }
+
+        const std::optional<UnionRequires> & get_top_level_requires() const { return top_level_requires; }
+        std::optional<UnionRequires> & get_mutable_top_level_requires() { return top_level_requires; }
+        void set_top_level_requires(const std::optional<UnionRequires> & value) { this->top_level_requires = value; }
+
+        const std::optional<UnionRestrict> & get_restrict() const { return restrict; }
+        std::optional<UnionRestrict> & get_mutable_restrict() { return restrict; }
+        void set_restrict(const std::optional<UnionRestrict> & value) { this->restrict = value; }
+
+        const std::optional<UnionRetain> & get_retain() const { return retain; }
+        std::optional<UnionRetain> & get_mutable_retain() { return retain; }
+        void set_retain(const std::optional<UnionRetain> & value) { this->retain = value; }
+
+        const std::optional<UnionRethrows> & get_rethrows() const { return rethrows; }
+        std::optional<UnionRethrows> & get_mutable_rethrows() { return rethrows; }
+        void set_rethrows(const std::optional<UnionRethrows> & value) { this->rethrows = value; }
+
+        const std::optional<UnionReturn> & get_top_level_return() const { return top_level_return; }
+        std::optional<UnionReturn> & get_mutable_top_level_return() { return top_level_return; }
+        void set_top_level_return(const std::optional<UnionReturn> & value) { this->top_level_return = value; }
+
+        const std::optional<UnionRight> & get_right() const { return right; }
+        std::optional<UnionRight> & get_mutable_right() { return right; }
+        void set_right(const std::optional<UnionRight> & value) { this->right = value; }
+
+        const std::optional<UnionSbyte> & get_sbyte() const { return sbyte; }
+        std::optional<UnionSbyte> & get_mutable_sbyte() { return sbyte; }
+        void set_sbyte(const std::optional<UnionSbyte> & value) { this->sbyte = value; }
+
+        const std::optional<UnionSealed> & get_sealed() const { return sealed; }
+        std::optional<UnionSealed> & get_mutable_sealed() { return sealed; }
+        void set_sealed(const std::optional<UnionSealed> & value) { this->sealed = value; }
+
+        const std::optional<UnionSel> & get_sel() const { return sel; }
+        std::optional<UnionSel> & get_mutable_sel() { return sel; }
+        void set_sel(const std::optional<UnionSel> & value) { this->sel = value; }
+
+        const std::optional<UnionSelect> & get_select() const { return select; }
+        std::optional<UnionSelect> & get_mutable_select() { return select; }
+        void set_select(const std::optional<UnionSelect> & value) { this->select = value; }
+
+        const std::optional<UnionSelf> & get_self() const { return self; }
+        std::optional<UnionSelf> & get_mutable_self() { return self; }
+        void set_self(const std::optional<UnionSelf> & value) { this->self = value; }
+
+        const std::optional<UnionSelfUnion> & get_top_level_self() const { return top_level_self; }
+        std::optional<UnionSelfUnion> & get_mutable_top_level_self() { return top_level_self; }
+        void set_top_level_self(const std::optional<UnionSelfUnion> & value) { this->top_level_self = value; }
+
+        const std::optional<UnionSerialize> & get_serialize() const { return serialize; }
+        std::optional<UnionSerialize> & get_mutable_serialize() { return serialize; }
+        void set_serialize(const std::optional<UnionSerialize> & value) { this->serialize = value; }
+
+        const std::optional<UnionSet> & get_set() const { return set; }
+        std::optional<UnionSet> & get_mutable_set() { return set; }
+        void set_set(const std::optional<UnionSet> & value) { this->set = value; }
+
+        const std::optional<UnionShort> & get_top_level_short() const { return top_level_short; }
+        std::optional<UnionShort> & get_mutable_top_level_short() { return top_level_short; }
+        void set_top_level_short(const std::optional<UnionShort> & value) { this->top_level_short = value; }
+
+        const std::optional<UnionSigned> & get_top_level_signed() const { return top_level_signed; }
+        std::optional<UnionSigned> & get_mutable_top_level_signed() { return top_level_signed; }
+        void set_top_level_signed(const std::optional<UnionSigned> & value) { this->top_level_signed = value; }
+
+        const std::optional<UnionSizeof> & get_top_level_sizeof() const { return top_level_sizeof; }
+        std::optional<UnionSizeof> & get_mutable_top_level_sizeof() { return top_level_sizeof; }
+        void set_top_level_sizeof(const std::optional<UnionSizeof> & value) { this->top_level_sizeof = value; }
+
+        const std::optional<UnionStackalloc> & get_stackalloc() const { return stackalloc; }
+        std::optional<UnionStackalloc> & get_mutable_stackalloc() { return stackalloc; }
+        void set_stackalloc(const std::optional<UnionStackalloc> & value) { this->stackalloc = value; }
+
+        const std::optional<UnionStatic> & get_top_level_static() const { return top_level_static; }
+        std::optional<UnionStatic> & get_mutable_top_level_static() { return top_level_static; }
+        void set_top_level_static(const std::optional<UnionStatic> & value) { this->top_level_static = value; }
+
+        const std::optional<UnionStaticAssert> & get_top_level_static_assert() const { return top_level_static_assert; }
+        std::optional<UnionStaticAssert> & get_mutable_top_level_static_assert() { return top_level_static_assert; }
+        void set_top_level_static_assert(const std::optional<UnionStaticAssert> & value) { this->top_level_static_assert = value; }
+
+        const std::optional<UnionStaticCast> & get_top_level_static_cast() const { return top_level_static_cast; }
+        std::optional<UnionStaticCast> & get_mutable_top_level_static_cast() { return top_level_static_cast; }
+        void set_top_level_static_cast(const std::optional<UnionStaticCast> & value) { this->top_level_static_cast = value; }
+
+        const std::optional<UnionStrictfp> & get_strictfp() const { return strictfp; }
+        std::optional<UnionStrictfp> & get_mutable_strictfp() { return strictfp; }
+        void set_strictfp(const std::optional<UnionStrictfp> & value) { this->strictfp = value; }
+
+        const std::optional<UnionString> & get_string() const { return string; }
+        std::optional<UnionString> & get_mutable_string() { return string; }
+        void set_string(const std::optional<UnionString> & value) { this->string = value; }
+
+        const std::optional<UnionStruct> & get_top_level_struct() const { return top_level_struct; }
+        std::optional<UnionStruct> & get_mutable_top_level_struct() { return top_level_struct; }
+        void set_top_level_struct(const std::optional<UnionStruct> & value) { this->top_level_struct = value; }
+
+        const std::optional<UnionSubscript> & get_subscript() const { return subscript; }
+        std::optional<UnionSubscript> & get_mutable_subscript() { return subscript; }
+        void set_subscript(const std::optional<UnionSubscript> & value) { this->subscript = value; }
+
+        const std::optional<UnionSuper> & get_super() const { return super; }
+        std::optional<UnionSuper> & get_mutable_super() { return super; }
+        void set_super(const std::optional<UnionSuper> & value) { this->super = value; }
+
+        const std::optional<UnionSwitch> & get_top_level_switch() const { return top_level_switch; }
+        std::optional<UnionSwitch> & get_mutable_top_level_switch() { return top_level_switch; }
+        void set_top_level_switch(const std::optional<UnionSwitch> & value) { this->top_level_switch = value; }
+
+        const std::optional<UnionSymbol> & get_symbol() const { return symbol; }
+        std::optional<UnionSymbol> & get_mutable_symbol() { return symbol; }
+        void set_symbol(const std::optional<UnionSymbol> & value) { this->symbol = value; }
+
+        const std::optional<UnionSynchronized> & get_top_level_synchronized() const { return top_level_synchronized; }
+        std::optional<UnionSynchronized> & get_mutable_top_level_synchronized() { return top_level_synchronized; }
+        void set_top_level_synchronized(const std::optional<UnionSynchronized> & value) { this->top_level_synchronized = value; }
+
+        const std::optional<UnionSystem> & get_system() const { return system; }
+        std::optional<UnionSystem> & get_mutable_system() { return system; }
+        void set_system(const std::optional<UnionSystem> & value) { this->system = value; }
+
+        const std::optional<UnionTemplate> & get_top_level_template() const { return top_level_template; }
+        std::optional<UnionTemplate> & get_mutable_top_level_template() { return top_level_template; }
+        void set_top_level_template(const std::optional<UnionTemplate> & value) { this->top_level_template = value; }
+
+        const std::optional<UnionThen> & get_then() const { return then; }
+        std::optional<UnionThen> & get_mutable_then() { return then; }
+        void set_then(const std::optional<UnionThen> & value) { this->then = value; }
+
+        const std::optional<UnionThis> & get_top_level_this() const { return top_level_this; }
+        std::optional<UnionThis> & get_mutable_top_level_this() { return top_level_this; }
+        void set_top_level_this(const std::optional<UnionThis> & value) { this->top_level_this = value; }
+
+        const std::optional<UnionThreadLocal> & get_top_level_thread_local() const { return top_level_thread_local; }
+        std::optional<UnionThreadLocal> & get_mutable_top_level_thread_local() { return top_level_thread_local; }
+        void set_top_level_thread_local(const std::optional<UnionThreadLocal> & value) { this->top_level_thread_local = value; }
+
+        const std::optional<UnionThrow> & get_top_level_throw() const { return top_level_throw; }
+        std::optional<UnionThrow> & get_mutable_top_level_throw() { return top_level_throw; }
+        void set_top_level_throw(const std::optional<UnionThrow> & value) { this->top_level_throw = value; }
+
+        const std::optional<UnionThrows> & get_throws() const { return throws; }
+        std::optional<UnionThrows> & get_mutable_throws() { return throws; }
+        void set_throws(const std::optional<UnionThrows> & value) { this->throws = value; }
+
+        const std::optional<UnionToJson> & get_to_json() const { return to_json; }
+        std::optional<UnionToJson> & get_mutable_to_json() { return to_json; }
+        void set_to_json(const std::optional<UnionToJson> & value) { this->to_json = value; }
+
+        const std::optional<UnionTopLevel> & get_top_level() const { return top_level; }
+        std::optional<UnionTopLevel> & get_mutable_top_level() { return top_level; }
+        void set_top_level(const std::optional<UnionTopLevel> & value) { this->top_level = value; }
+
+        const std::optional<UnionTransient> & get_transient() const { return transient; }
+        std::optional<UnionTransient> & get_mutable_transient() { return transient; }
+        void set_transient(const std::optional<UnionTransient> & value) { this->transient = value; }
+
+        const std::optional<UnionTrue> & get_top_level_true() const { return top_level_true; }
+        std::optional<UnionTrue> & get_mutable_top_level_true() { return top_level_true; }
+        void set_top_level_true(const std::optional<UnionTrue> & value) { this->top_level_true = value; }
+
+        const std::optional<UnionTrueUnion> & get_purple_true() const { return purple_true; }
+        std::optional<UnionTrueUnion> & get_mutable_purple_true() { return purple_true; }
+        void set_purple_true(const std::optional<UnionTrueUnion> & value) { this->purple_true = value; }
+
+        const std::optional<UnionTry> & get_top_level_try() const { return top_level_try; }
+        std::optional<UnionTry> & get_mutable_top_level_try() { return top_level_try; }
+        void set_top_level_try(const std::optional<UnionTry> & value) { this->top_level_try = value; }
+
+        const std::optional<UnionType> & get_type() const { return type; }
+        std::optional<UnionType> & get_mutable_type() { return type; }
+        void set_type(const std::optional<UnionType> & value) { this->type = value; }
+
+        const std::optional<UnionTypeUnion> & get_top_level_type() const { return top_level_type; }
+        std::optional<UnionTypeUnion> & get_mutable_top_level_type() { return top_level_type; }
+        void set_top_level_type(const std::optional<UnionTypeUnion> & value) { this->top_level_type = value; }
+
+        const std::optional<UnionTypealias> & get_typealias() const { return typealias; }
+        std::optional<UnionTypealias> & get_mutable_typealias() { return typealias; }
+        void set_typealias(const std::optional<UnionTypealias> & value) { this->typealias = value; }
+
+        const std::optional<UnionTypedef> & get_top_level_typedef() const { return top_level_typedef; }
+        std::optional<UnionTypedef> & get_mutable_top_level_typedef() { return top_level_typedef; }
+        void set_top_level_typedef(const std::optional<UnionTypedef> & value) { this->top_level_typedef = value; }
+
+        const std::optional<UnionTypeid> & get_top_level_typeid() const { return top_level_typeid; }
+        std::optional<UnionTypeid> & get_mutable_top_level_typeid() { return top_level_typeid; }
+        void set_top_level_typeid(const std::optional<UnionTypeid> & value) { this->top_level_typeid = value; }
+
+        const std::optional<UnionTypename> & get_top_level_typename() const { return top_level_typename; }
+        std::optional<UnionTypename> & get_mutable_top_level_typename() { return top_level_typename; }
+        void set_top_level_typename(const std::optional<UnionTypename> & value) { this->top_level_typename = value; }
+
+        const std::optional<UnionTypeof> & get_typeof() const { return typeof; }
+        std::optional<UnionTypeof> & get_mutable_typeof() { return typeof; }
+        void set_typeof(const std::optional<UnionTypeof> & value) { this->typeof = value; }
+
+        const std::optional<UnionUint> & get_uint() const { return uint; }
+        std::optional<UnionUint> & get_mutable_uint() { return uint; }
+        void set_uint(const std::optional<UnionUint> & value) { this->uint = value; }
+
+        const std::optional<UnionUlong> & get_ulong() const { return ulong; }
+        std::optional<UnionUlong> & get_mutable_ulong() { return ulong; }
+        void set_ulong(const std::optional<UnionUlong> & value) { this->ulong = value; }
+
+        const std::optional<UnionUnchecked> & get_unchecked() const { return unchecked; }
+        std::optional<UnionUnchecked> & get_mutable_unchecked() { return unchecked; }
+        void set_unchecked(const std::optional<UnionUnchecked> & value) { this->unchecked = value; }
+
+        const std::optional<UnionUndefined> & get_undefined() const { return undefined; }
+        std::optional<UnionUndefined> & get_mutable_undefined() { return undefined; }
+        void set_undefined(const std::optional<UnionUndefined> & value) { this->undefined = value; }
+
+        const std::optional<UnionUnionUnion> & get_top_level_union() const { return top_level_union; }
+        std::optional<UnionUnionUnion> & get_mutable_top_level_union() { return top_level_union; }
+        void set_top_level_union(const std::optional<UnionUnionUnion> & value) { this->top_level_union = value; }
+
+        const std::optional<UnionUnowned> & get_unowned() const { return unowned; }
+        std::optional<UnionUnowned> & get_mutable_unowned() { return unowned; }
+        void set_unowned(const std::optional<UnionUnowned> & value) { this->unowned = value; }
+
+        const std::optional<UnionUnsafe> & get_unsafe() const { return unsafe; }
+        std::optional<UnionUnsafe> & get_mutable_unsafe() { return unsafe; }
+        void set_unsafe(const std::optional<UnionUnsafe> & value) { this->unsafe = value; }
+
+        const std::optional<UnionUnsigned> & get_top_level_unsigned() const { return top_level_unsigned; }
+        std::optional<UnionUnsigned> & get_mutable_top_level_unsigned() { return top_level_unsigned; }
+        void set_top_level_unsigned(const std::optional<UnionUnsigned> & value) { this->top_level_unsigned = value; }
+
+        const std::optional<UnionUshort> & get_ushort() const { return ushort; }
+        std::optional<UnionUshort> & get_mutable_ushort() { return ushort; }
+        void set_ushort(const std::optional<UnionUshort> & value) { this->ushort = value; }
+
+        const std::optional<UnionUsing> & get_top_level_using() const { return top_level_using; }
+        std::optional<UnionUsing> & get_mutable_top_level_using() { return top_level_using; }
+        void set_top_level_using(const std::optional<UnionUsing> & value) { this->top_level_using = value; }
+
+        const std::optional<UnionVar> & get_var() const { return var; }
+        std::optional<UnionVar> & get_mutable_var() { return var; }
+        void set_var(const std::optional<UnionVar> & value) { this->var = value; }
+
+        const std::optional<UnionVirtual> & get_top_level_virtual() const { return top_level_virtual; }
+        std::optional<UnionVirtual> & get_mutable_top_level_virtual() { return top_level_virtual; }
+        void set_top_level_virtual(const std::optional<UnionVirtual> & value) { this->top_level_virtual = value; }
+
+        const std::optional<UnionVoid> & get_top_level_void() const { return top_level_void; }
+        std::optional<UnionVoid> & get_mutable_top_level_void() { return top_level_void; }
+        void set_top_level_void(const std::optional<UnionVoid> & value) { this->top_level_void = value; }
+
+        const std::optional<UnionVolatile> & get_top_level_volatile() const { return top_level_volatile; }
+        std::optional<UnionVolatile> & get_mutable_top_level_volatile() { return top_level_volatile; }
+        void set_top_level_volatile(const std::optional<UnionVolatile> & value) { this->top_level_volatile = value; }
+
+        const std::optional<UnionWcharT> & get_top_level_wchar_t() const { return top_level_wchar_t; }
+        std::optional<UnionWcharT> & get_mutable_top_level_wchar_t() { return top_level_wchar_t; }
+        void set_top_level_wchar_t(const std::optional<UnionWcharT> & value) { this->top_level_wchar_t = value; }
+
+        const std::optional<UnionWeak> & get_weak() const { return weak; }
+        std::optional<UnionWeak> & get_mutable_weak() { return weak; }
+        void set_weak(const std::optional<UnionWeak> & value) { this->weak = value; }
+
+        const std::optional<UnionWhere> & get_where() const { return where; }
+        std::optional<UnionWhere> & get_mutable_where() { return where; }
+        void set_where(const std::optional<UnionWhere> & value) { this->where = value; }
+
+        const std::optional<UnionWhile> & get_top_level_while() const { return top_level_while; }
+        std::optional<UnionWhile> & get_mutable_top_level_while() { return top_level_while; }
+        void set_top_level_while(const std::optional<UnionWhile> & value) { this->top_level_while = value; }
+
+        const std::optional<UnionWillSet> & get_will_set() const { return will_set; }
+        std::optional<UnionWillSet> & get_mutable_will_set() { return will_set; }
+        void set_will_set(const std::optional<UnionWillSet> & value) { this->will_set = value; }
+
+        const std::optional<UnionWith> & get_with() const { return with; }
+        std::optional<UnionWith> & get_mutable_with() { return with; }
+        void set_with(const std::optional<UnionWith> & value) { this->with = value; }
+
+        const std::optional<UnionXor> & get_top_level_xor() const { return top_level_xor; }
+        std::optional<UnionXor> & get_mutable_top_level_xor() { return top_level_xor; }
+        void set_top_level_xor(const std::optional<UnionXor> & value) { this->top_level_xor = value; }
+
+        const std::optional<UnionXorEq> & get_top_level_xor_eq() const { return top_level_xor_eq; }
+        std::optional<UnionXorEq> & get_mutable_top_level_xor_eq() { return top_level_xor_eq; }
+        void set_top_level_xor_eq(const std::optional<UnionXorEq> & value) { this->top_level_xor_eq = value; }
+
+        const std::optional<UnionYes> & get_yes() const { return yes; }
+        std::optional<UnionYes> & get_mutable_yes() { return yes; }
+        void set_yes(const std::optional<UnionYes> & value) { this->yes = value; }
+
+        const std::optional<UnionYield> & get_yield() const { return yield; }
+        std::optional<UnionYield> & get_mutable_yield() { return yield; }
+        void set_yield(const std::optional<UnionYield> & value) { this->yield = value; }
+    };
+}
+
+namespace quicktype {
+void from_json(const json & j, Abstract & x);
+void to_json(json & j, const Abstract & x);
+
+void from_json(const json & j, Any & x);
+void to_json(json & j, const Any & x);
+
+void from_json(const json & j, Array & x);
+void to_json(json & j, const Array & x);
+
+void from_json(const json & j, As & x);
+void to_json(json & j, const As & x);
+
+void from_json(const json & j, Assert & x);
+void to_json(json & j, const Assert & x);
+
+void from_json(const json & j, Associatedtype & x);
+void to_json(json & j, const Associatedtype & x);
+
+void from_json(const json & j, Associativity & x);
+void to_json(json & j, const Associativity & x);
+
+void from_json(const json & j, Async & x);
+void to_json(json & j, const Async & x);
+
+void from_json(const json & j, Atomic & x);
+void to_json(json & j, const Atomic & x);
+
+void from_json(const json & j, Await & x);
+void to_json(json & j, const Await & x);
+
+void from_json(const json & j, Base & x);
+void to_json(json & j, const Base & x);
+
+void from_json(const json & j, Boolean & x);
+void to_json(json & j, const Boolean & x);
+
+void from_json(const json & j, Bycopy & x);
+void to_json(json & j, const Bycopy & x);
+
+void from_json(const json & j, Byref & x);
+void to_json(json & j, const Byref & x);
+
+void from_json(const json & j, Byte & x);
+void to_json(json & j, const Byte & x);
+
+void from_json(const json & j, Chan & x);
+void to_json(json & j, const Chan & x);
+
+void from_json(const json & j, Checked & x);
+void to_json(json & j, const Checked & x);
+
+void from_json(const json & j, Complex & x);
+void to_json(json & j, const Complex & x);
+
+void from_json(const json & j, Console & x);
+void to_json(json & j, const Console & x);
+
+void from_json(const json & j, Constructor & x);
+void to_json(json & j, const Constructor & x);
+
+void from_json(const json & j, Convenience & x);
+void to_json(json & j, const Convenience & x);
+
+void from_json(const json & j, Convert & x);
+void to_json(json & j, const Convert & x);
+
+void from_json(const json & j, Converter & x);
+void to_json(json & j, const Converter & x);
+
+void from_json(const json & j, Date & x);
+void to_json(json & j, const Date & x);
+
+void from_json(const json & j, DateParseHandling & x);
+void to_json(json & j, const DateParseHandling & x);
+
+void from_json(const json & j, Debugger & x);
+void to_json(json & j, const Debugger & x);
+
+void from_json(const json & j, Decimal & x);
+void to_json(json & j, const Decimal & x);
+
+void from_json(const json & j, Declare & x);
+void to_json(json & j, const Declare & x);
+
+void from_json(const json & j, DecodeString & x);
+void to_json(json & j, const DecodeString & x);
+
+void from_json(const json & j, Def & x);
+void to_json(json & j, const Def & x);
+
+void from_json(const json & j, Defer & x);
+void to_json(json & j, const Defer & x);
+
+void from_json(const json & j, Deinit & x);
+void to_json(json & j, const Deinit & x);
+
+void from_json(const json & j, Del & x);
+void to_json(json & j, const Del & x);
+
+void from_json(const json & j, Delegate & x);
+void to_json(json & j, const Delegate & x);
+
+void from_json(const json & j, Dict & x);
+void to_json(json & j, const Dict & x);
+
+void from_json(const json & j, Dictionary & x);
+void to_json(json & j, const Dictionary & x);
+
+void from_json(const json & j, DidSet & x);
+void to_json(json & j, const DidSet & x);
+
+void from_json(const json & j, Dynamic & x);
+void to_json(json & j, const Dynamic & x);
+
+void from_json(const json & j, Elif & x);
+void to_json(json & j, const Elif & x);
+
+void from_json(const json & j, Empty & x);
+void to_json(json & j, const Empty & x);
+
+void from_json(const json & j, EncodeQuickType & x);
+void to_json(json & j, const EncodeQuickType & x);
+
+void from_json(const json & j, Event & x);
+void to_json(json & j, const Event & x);
+
+void from_json(const json & j, Except & x);
+void to_json(json & j, const Except & x);
+
+void from_json(const json & j, Exception & x);
+void to_json(json & j, const Exception & x);
+
+void from_json(const json & j, Exposing & x);
+void to_json(json & j, const Exposing & x);
+
+void from_json(const json & j, Extends & x);
+void to_json(json & j, const Extends & x);
+
+void from_json(const json & j, Extension & x);
+void to_json(json & j, const Extension & x);
+
+void from_json(const json & j, Fallthrough & x);
+void to_json(json & j, const Fallthrough & x);
+
+void from_json(const json & j, Fileprivate & x);
+void to_json(json & j, const Fileprivate & x);
+
+void from_json(const json & j, Finally & x);
+void to_json(json & j, const Finally & x);
+
+void from_json(const json & j, Fixed & x);
+void to_json(json & j, const Fixed & x);
+
+void from_json(const json & j, UnionBoolBool & x);
+void to_json(json & j, const UnionBoolBool & x);
+
+void from_json(const json & j, Foreach & x);
+void to_json(json & j, const Foreach & x);
+
+void from_json(const json & j, From & x);
+void to_json(json & j, const From & x);
+
+void from_json(const json & j, FromJson & x);
+void to_json(json & j, const FromJson & x);
+
+void from_json(const json & j, Func & x);
+void to_json(json & j, const Func & x);
+
+void from_json(const json & j, Function & x);
+void to_json(json & j, const Function & x);
+
+void from_json(const json & j, Get & x);
+void to_json(json & j, const Get & x);
+
+void from_json(const json & j, Global & x);
+void to_json(json & j, const Global & x);
+
+void from_json(const json & j, Go & x);
+void to_json(json & j, const Go & x);
+
+void from_json(const json & j, Guard & x);
+void to_json(json & j, const Guard & x);
+
+void from_json(const json & j, HasOwnProperty & x);
+void to_json(json & j, const HasOwnProperty & x);
+
+void from_json(const json & j, Id & x);
+void to_json(json & j, const Id & x);
+
+void from_json(const json & j, Imaginery & x);
+void to_json(json & j, const Imaginery & x);
+
+void from_json(const json & j, Imp & x);
+void to_json(json & j, const Imp & x);
+
+void from_json(const json & j, Implements & x);
+void to_json(json & j, const Implements & x);
+
+void from_json(const json & j, Implicit & x);
+void to_json(json & j, const Implicit & x);
+
+void from_json(const json & j, In & x);
+void to_json(json & j, const In & x);
+
+void from_json(const json & j, Indirect & x);
+void to_json(json & j, const Indirect & x);
+
+void from_json(const json & j, Infix & x);
+void to_json(json & j, const Infix & x);
+
+void from_json(const json & j, Init & x);
+void to_json(json & j, const Init & x);
+
+void from_json(const json & j, Inout & x);
+void to_json(json & j, const Inout & x);
+
+void from_json(const json & j, Instanceof & x);
+void to_json(json & j, const Instanceof & x);
+
+void from_json(const json & j, Interface & x);
+void to_json(json & j, const Interface & x);
+
+void from_json(const json & j, Internal & x);
+void to_json(json & j, const Internal & x);
+
+void from_json(const json & j, Is & x);
+void to_json(json & j, const Is & x);
+
+void from_json(const json & j, Iterable & x);
+void to_json(json & j, const Iterable & x);
+
+void from_json(const json & j, Jdec & x);
+void to_json(json & j, const Jdec & x);
+
+void from_json(const json & j, Jenc & x);
+void to_json(json & j, const Jenc & x);
+
+void from_json(const json & j, Jpipe & x);
+void to_json(json & j, const Jpipe & x);
+
+void from_json(const json & j, Json & x);
+void to_json(json & j, const Json & x);
+
+void from_json(const json & j, JsonConverter & x);
+void to_json(json & j, const JsonConverter & x);
+
+void from_json(const json & j, JsonSerializer & x);
+void to_json(json & j, const JsonSerializer & x);
+
+void from_json(const json & j, JsonToken & x);
+void to_json(json & j, const JsonToken & x);
+
+void from_json(const json & j, JsonWriter & x);
+void to_json(json & j, const JsonWriter & x);
+
+void from_json(const json & j, Lambda & x);
+void to_json(json & j, const Lambda & x);
+
+void from_json(const json & j, Lazy & x);
+void to_json(json & j, const Lazy & x);
+
+void from_json(const json & j, Left & x);
+void to_json(json & j, const Left & x);
+
+void from_json(const json & j, Let & x);
+void to_json(json & j, const Let & x);
+
+void from_json(const json & j, List & x);
+void to_json(json & j, const List & x);
+
+void from_json(const json & j, Lock & x);
+void to_json(json & j, const Lock & x);
+
+void from_json(const json & j, Map & x);
+void to_json(json & j, const Map & x);
+
+void from_json(const json & j, MetadataPropertyHandling & x);
+void to_json(json & j, const MetadataPropertyHandling & x);
+
+void from_json(const json & j, Mutating & x);
+void to_json(json & j, const Mutating & x);
+
+void from_json(const json & j, Native & x);
+void to_json(json & j, const Native & x);
+
+void from_json(const json & j, Newtonsoft & x);
+void to_json(json & j, const Newtonsoft & x);
+
+void from_json(const json & j, Nil & x);
+void to_json(json & j, const Nil & x);
+
+void from_json(const json & j, No & x);
+void to_json(json & j, const No & x);
+
+void from_json(const json & j, Nonatomic & x);
+void to_json(json & j, const Nonatomic & x);
+
+void from_json(const json & j, None & x);
+void to_json(json & j, const None & x);
+
+void from_json(const json & j, Nonlocal & x);
+void to_json(json & j, const Nonlocal & x);
+
+void from_json(const json & j, Nonmutating & x);
+void to_json(json & j, const Nonmutating & x);
+
+void from_json(const json & j, NsString & x);
+void to_json(json & j, const NsString & x);
+
+void from_json(const json & j, Null & x);
+void to_json(json & j, const Null & x);
+
+void from_json(const json & j, Number & x);
+void to_json(json & j, const Number & x);
+
+void from_json(const json & j, Object & x);
+void to_json(json & j, const Object & x);
+
+void from_json(const json & j, Of & x);
+void to_json(json & j, const Of & x);
+
+void from_json(const json & j, Oneway & x);
+void to_json(json & j, const Oneway & x);
+
+void from_json(const json & j, Open & x);
+void to_json(json & j, const Open & x);
+
+void from_json(const json & j, Optional & x);
+void to_json(json & j, const Optional & x);
+
+void from_json(const json & j, Out & x);
+void to_json(json & j, const Out & x);
+
+void from_json(const json & j, Package & x);
+void to_json(json & j, const Package & x);
+
+void from_json(const json & j, Params & x);
+void to_json(json & j, const Params & x);
+
+void from_json(const json & j, Pass & x);
+void to_json(json & j, const Pass & x);
+
+void from_json(const json & j, Port & x);
+void to_json(json & j, const Port & x);
+
+void from_json(const json & j, Postfix & x);
+void to_json(json & j, const Postfix & x);
+
+void from_json(const json & j, Precedence & x);
+void to_json(json & j, const Precedence & x);
+
+void from_json(const json & j, Prefix & x);
+void to_json(json & j, const Prefix & x);
+
+void from_json(const json & j, Print & x);
+void to_json(json & j, const Print & x);
+
+void from_json(const json & j, Printf & x);
+void to_json(json & j, const Printf & x);
+
+void from_json(const json & j, Protocol & x);
+void to_json(json & j, const Protocol & x);
+
+void from_json(const json & j, BoolClass & x);
+void to_json(json & j, const BoolClass & x);
+
+void from_json(const json & j, ClassClass & x);
+void to_json(json & j, const ClassClass & x);
+
+void from_json(const json & j, FalseClass & x);
+void to_json(json & j, const FalseClass & x);
+
+void from_json(const json & j, TrueClass & x);
+void to_json(json & j, const TrueClass & x);
+
+void from_json(const json & j, Quicktype & x);
+void to_json(json & j, const Quicktype & x);
+
+void from_json(const json & j, Raise & x);
+void to_json(json & j, const Raise & x);
+
+void from_json(const json & j, Range & x);
+void to_json(json & j, const Range & x);
+
+void from_json(const json & j, Readonly & x);
+void to_json(json & j, const Readonly & x);
+
+void from_json(const json & j, Ref & x);
+void to_json(json & j, const Ref & x);
+
+void from_json(const json & j, Repeat & x);
+void to_json(json & j, const Repeat & x);
+
+void from_json(const json & j, Require & x);
+void to_json(json & j, const Require & x);
+
+void from_json(const json & j, Required & x);
+void to_json(json & j, const Required & x);
+
+void from_json(const json & j, Restrict & x);
+void to_json(json & j, const Restrict & x);
+
+void from_json(const json & j, Retain & x);
+void to_json(json & j, const Retain & x);
+
+void from_json(const json & j, Rethrows & x);
+void to_json(json & j, const Rethrows & x);
+
+void from_json(const json & j, Right & x);
+void to_json(json & j, const Right & x);
+
+void from_json(const json & j, Sbyte & x);
+void to_json(json & j, const Sbyte & x);
+
+void from_json(const json & j, Sealed & x);
+void to_json(json & j, const Sealed & x);
+
+void from_json(const json & j, Sel & x);
+void to_json(json & j, const Sel & x);
+
+void from_json(const json & j, Select & x);
+void to_json(json & j, const Select & x);
+
+void from_json(const json & j, Self & x);
+void to_json(json & j, const Self & x);
+
+void from_json(const json & j, Serialize & x);
+void to_json(json & j, const Serialize & x);
+
+void from_json(const json & j, Set & x);
+void to_json(json & j, const Set & x);
+
+void from_json(const json & j, Stackalloc & x);
+void to_json(json & j, const Stackalloc & x);
+
+void from_json(const json & j, Strictfp & x);
+void to_json(json & j, const Strictfp & x);
+
+void from_json(const json & j, String & x);
+void to_json(json & j, const String & x);
+
+void from_json(const json & j, Subscript & x);
+void to_json(json & j, const Subscript & x);
+
+void from_json(const json & j, Super & x);
+void to_json(json & j, const Super & x);
+
+void from_json(const json & j, Symbol & x);
+void to_json(json & j, const Symbol & x);
+
+void from_json(const json & j, System & x);
+void to_json(json & j, const System & x);
+
+void from_json(const json & j, Then & x);
+void to_json(json & j, const Then & x);
+
+void from_json(const json & j, Throws & x);
+void to_json(json & j, const Throws & x);
+
+void from_json(const json & j, ToJson & x);
+void to_json(json & j, const ToJson & x);
+
+void from_json(const json & j, TopLevelClass & x);
+void to_json(json & j, const TopLevelClass & x);
+
+void from_json(const json & j, Alignas & x);
+void to_json(json & j, const Alignas & x);
+
+void from_json(const json & j, Alignof & x);
+void to_json(json & j, const Alignof & x);
+
+void from_json(const json & j, And & x);
+void to_json(json & j, const And & x);
+
+void from_json(const json & j, AndEq & x);
+void to_json(json & j, const AndEq & x);
+
+void from_json(const json & j, AnyClass & x);
+void to_json(json & j, const AnyClass & x);
+
+void from_json(const json & j, Asm & x);
+void to_json(json & j, const Asm & x);
+
+void from_json(const json & j, AtomicCancel & x);
+void to_json(json & j, const AtomicCancel & x);
+
+void from_json(const json & j, AtomicCommit & x);
+void to_json(json & j, const AtomicCommit & x);
+
+void from_json(const json & j, AtomicNoexcept & x);
+void to_json(json & j, const AtomicNoexcept & x);
+
+void from_json(const json & j, Auto & x);
+void to_json(json & j, const Auto & x);
+
+void from_json(const json & j, Bitand & x);
+void to_json(json & j, const Bitand & x);
+
+void from_json(const json & j, Bitor & x);
+void to_json(json & j, const Bitor & x);
+
+void from_json(const json & j, Bool & x);
+void to_json(json & j, const Bool & x);
+
+void from_json(const json & j, Break & x);
+void to_json(json & j, const Break & x);
+
+void from_json(const json & j, Case & x);
+void to_json(json & j, const Case & x);
+
+void from_json(const json & j, Catch & x);
+void to_json(json & j, const Catch & x);
+
+void from_json(const json & j, Char & x);
+void to_json(json & j, const Char & x);
+
+void from_json(const json & j, Char16T & x);
+void to_json(json & j, const Char16T & x);
+
+void from_json(const json & j, Char32T & x);
+void to_json(json & j, const Char32T & x);
+
+void from_json(const json & j, Class & x);
+void to_json(json & j, const Class & x);
+
+void from_json(const json & j, CoAwait & x);
+void to_json(json & j, const CoAwait & x);
+
+void from_json(const json & j, CoReturn & x);
+void to_json(json & j, const CoReturn & x);
+
+void from_json(const json & j, CoYield & x);
+void to_json(json & j, const CoYield & x);
+
+void from_json(const json & j, Compl & x);
+void to_json(json & j, const Compl & x);
+
+void from_json(const json & j, Concept & x);
+void to_json(json & j, const Concept & x);
+
+void from_json(const json & j, Const & x);
+void to_json(json & j, const Const & x);
+
+void from_json(const json & j, ConstCast & x);
+void to_json(json & j, const ConstCast & x);
+
+void from_json(const json & j, Constexpr & x);
+void to_json(json & j, const Constexpr & x);
+
+void from_json(const json & j, Continue & x);
+void to_json(json & j, const Continue & x);
+
+void from_json(const json & j, Decltype & x);
+void to_json(json & j, const Decltype & x);
+
+void from_json(const json & j, Default & x);
+void to_json(json & j, const Default & x);
+
+void from_json(const json & j, Delete & x);
+void to_json(json & j, const Delete & x);
+
+void from_json(const json & j, Do & x);
+void to_json(json & j, const Do & x);
+
+void from_json(const json & j, Double & x);
+void to_json(json & j, const Double & x);
+
+void from_json(const json & j, DynamicCast & x);
+void to_json(json & j, const DynamicCast & x);
+
+void from_json(const json & j, Else & x);
+void to_json(json & j, const Else & x);
+
+void from_json(const json & j, Enum & x);
+void to_json(json & j, const Enum & x);
+
+void from_json(const json & j, Explicit & x);
+void to_json(json & j, const Explicit & x);
+
+void from_json(const json & j, Export & x);
+void to_json(json & j, const Export & x);
+
+void from_json(const json & j, Extern & x);
+void to_json(json & j, const Extern & x);
+
+void from_json(const json & j, False & x);
+void to_json(json & j, const False & x);
+
+void from_json(const json & j, Final & x);
+void to_json(json & j, const Final & x);
+
+void from_json(const json & j, Float & x);
+void to_json(json & j, const Float & x);
+
+void from_json(const json & j, For & x);
+void to_json(json & j, const For & x);
+
+void from_json(const json & j, Friend & x);
+void to_json(json & j, const Friend & x);
+
+void from_json(const json & j, Goto & x);
+void to_json(json & j, const Goto & x);
+
+void from_json(const json & j, If & x);
+void to_json(json & j, const If & x);
+
+void from_json(const json & j, Import & x);
+void to_json(json & j, const Import & x);
+
+void from_json(const json & j, Inline & x);
+void to_json(json & j, const Inline & x);
+
+void from_json(const json & j, Int & x);
+void to_json(json & j, const Int & x);
+
+void from_json(const json & j, Long & x);
+void to_json(json & j, const Long & x);
+
+void from_json(const json & j, Module & x);
+void to_json(json & j, const Module & x);
+
+void from_json(const json & j, Mutable & x);
+void to_json(json & j, const Mutable & x);
+
+void from_json(const json & j, Namespace & x);
+void to_json(json & j, const Namespace & x);
+
+void from_json(const json & j, New & x);
+void to_json(json & j, const New & x);
+
+void from_json(const json & j, Noexcept & x);
+void to_json(json & j, const Noexcept & x);
+
+void from_json(const json & j, NoneClass & x);
+void to_json(json & j, const NoneClass & x);
+
+void from_json(const json & j, Not & x);
+void to_json(json & j, const Not & x);
+
+void from_json(const json & j, NotEq & x);
+void to_json(json & j, const NotEq & x);
+
+void from_json(const json & j, NullClass & x);
+void to_json(json & j, const NullClass & x);
+
+void from_json(const json & j, Nullptr & x);
+void to_json(json & j, const Nullptr & x);
+
+void from_json(const json & j, Operator & x);
+void to_json(json & j, const Operator & x);
+
+void from_json(const json & j, Or & x);
+void to_json(json & j, const Or & x);
+
+void from_json(const json & j, OrEq & x);
+void to_json(json & j, const OrEq & x);
+
+void from_json(const json & j, Override & x);
+void to_json(json & j, const Override & x);
+
+void from_json(const json & j, Private & x);
+void to_json(json & j, const Private & x);
+
+void from_json(const json & j, Protected & x);
+void to_json(json & j, const Protected & x);
+
+void from_json(const json & j, ProtocolClass & x);
+void to_json(json & j, const ProtocolClass & x);
+
+void from_json(const json & j, Public & x);
+void to_json(json & j, const Public & x);
+
+void from_json(const json & j, Register & x);
+void to_json(json & j, const Register & x);
+
+void from_json(const json & j, ReinterpretCast & x);
+void to_json(json & j, const ReinterpretCast & x);
+
+void from_json(const json & j, Requires & x);
+void to_json(json & j, const Requires & x);
+
+void from_json(const json & j, Return & x);
+void to_json(json & j, const Return & x);
+
+void from_json(const json & j, SelfClass & x);
+void to_json(json & j, const SelfClass & x);
+
+void from_json(const json & j, Short & x);
+void to_json(json & j, const Short & x);
+
+void from_json(const json & j, Signed & x);
+void to_json(json & j, const Signed & x);
+
+void from_json(const json & j, Sizeof & x);
+void to_json(json & j, const Sizeof & x);
+
+void from_json(const json & j, Static & x);
+void to_json(json & j, const Static & x);
+
+void from_json(const json & j, StaticAssert & x);
+void to_json(json & j, const StaticAssert & x);
+
+void from_json(const json & j, StaticCast & x);
+void to_json(json & j, const StaticCast & x);
+
+void from_json(const json & j, Struct & x);
+void to_json(json & j, const Struct & x);
+
+void from_json(const json & j, Switch & x);
+void to_json(json & j, const Switch & x);
+
+void from_json(const json & j, Synchronized & x);
+void to_json(json & j, const Synchronized & x);
+
+void from_json(const json & j, Template & x);
+void to_json(json & j, const Template & x);
+
+void from_json(const json & j, This & x);
+void to_json(json & j, const This & x);
+
+void from_json(const json & j, ThreadLocal & x);
+void to_json(json & j, const ThreadLocal & x);
+
+void from_json(const json & j, Throw & x);
+void to_json(json & j, const Throw & x);
+
+void from_json(const json & j, True & x);
+void to_json(json & j, const True & x);
+
+void from_json(const json & j, Try & x);
+void to_json(json & j, const Try & x);
+
+void from_json(const json & j, TypeClass & x);
+void to_json(json & j, const TypeClass & x);
+
+void from_json(const json & j, Typedef & x);
+void to_json(json & j, const Typedef & x);
+
+void from_json(const json & j, Typeid & x);
+void to_json(json & j, const Typeid & x);
+
+void from_json(const json & j, Typename & x);
+void to_json(json & j, const Typename & x);
+
+void from_json(const json & j, Union & x);
+void to_json(json & j, const Union & x);
+
+void from_json(const json & j, Unsigned & x);
+void to_json(json & j, const Unsigned & x);
+
+void from_json(const json & j, Using & x);
+void to_json(json & j, const Using & x);
+
+void from_json(const json & j, Virtual & x);
+void to_json(json & j, const Virtual & x);
+
+void from_json(const json & j, Void & x);
+void to_json(json & j, const Void & x);
+
+void from_json(const json & j, Volatile & x);
+void to_json(json & j, const Volatile & x);
+
+void from_json(const json & j, WcharT & x);
+void to_json(json & j, const WcharT & x);
+
+void from_json(const json & j, While & x);
+void to_json(json & j, const While & x);
+
+void from_json(const json & j, Xor & x);
+void to_json(json & j, const Xor & x);
+
+void from_json(const json & j, XorEq & x);
+void to_json(json & j, const XorEq & x);
+
+void from_json(const json & j, Transient & x);
+void to_json(json & j, const Transient & x);
+
+void from_json(const json & j, Type & x);
+void to_json(json & j, const Type & x);
+
+void from_json(const json & j, Typealias & x);
+void to_json(json & j, const Typealias & x);
+
+void from_json(const json & j, Typeof & x);
+void to_json(json & j, const Typeof & x);
+
+void from_json(const json & j, Uint & x);
+void to_json(json & j, const Uint & x);
+
+void from_json(const json & j, Ulong & x);
+void to_json(json & j, const Ulong & x);
+
+void from_json(const json & j, Unchecked & x);
+void to_json(json & j, const Unchecked & x);
+
+void from_json(const json & j, Undefined & x);
+void to_json(json & j, const Undefined & x);
+
+void from_json(const json & j, Unowned & x);
+void to_json(json & j, const Unowned & x);
+
+void from_json(const json & j, Unsafe & x);
+void to_json(json & j, const Unsafe & x);
+
+void from_json(const json & j, Ushort & x);
+void to_json(json & j, const Ushort & x);
+
+void from_json(const json & j, Var & x);
+void to_json(json & j, const Var & x);
+
+void from_json(const json & j, Weak & x);
+void to_json(json & j, const Weak & x);
+
+void from_json(const json & j, Where & x);
+void to_json(json & j, const Where & x);
+
+void from_json(const json & j, WillSet & x);
+void to_json(json & j, const WillSet & x);
+
+void from_json(const json & j, With & x);
+void to_json(json & j, const With & x);
+
+void from_json(const json & j, Yes & x);
+void to_json(json & j, const Yes & x);
+
+void from_json(const json & j, Yield & x);
+void to_json(json & j, const Yield & x);
+
+void from_json(const json & j, TopLevel & x);
+void to_json(json & j, const TopLevel & x);
+}
+namespace nlohmann {
+template <>
+struct adl_serializer<std::variant<quicktype::Abstract, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Abstract, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Abstract, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Any, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Any, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Any, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Array, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Array, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Array, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::As, double>> {
+    static void from_json(const json & j, std::variant<quicktype::As, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::As, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Assert, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Assert, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Assert, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Associatedtype, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Associatedtype, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Associatedtype, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Associativity, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Associativity, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Associativity, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Async, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Async, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Async, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Atomic, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Atomic, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Atomic, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Await, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Await, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Await, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Base, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Base, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Base, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Boolean, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Boolean, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Boolean, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Bycopy, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Bycopy, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Bycopy, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Byref, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Byref, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Byref, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Byte, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Byte, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Byte, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Chan, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Chan, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Chan, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Checked, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Checked, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Checked, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Complex, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Complex, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Complex, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Console, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Console, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Console, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Constructor, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Constructor, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Constructor, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Convenience, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Convenience, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Convenience, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Convert, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Convert, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Convert, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Converter, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Converter, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Converter, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Date, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Date, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Date, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::DateParseHandling, double>> {
+    static void from_json(const json & j, std::variant<quicktype::DateParseHandling, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::DateParseHandling, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Debugger, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Debugger, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Debugger, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Decimal, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Decimal, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Decimal, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Declare, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Declare, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Declare, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::DecodeString, double>> {
+    static void from_json(const json & j, std::variant<quicktype::DecodeString, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::DecodeString, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Def, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Def, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Def, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Defer, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Defer, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Defer, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Deinit, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Deinit, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Deinit, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Del, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Del, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Del, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Delegate, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Delegate, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Delegate, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Dict, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Dict, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Dict, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Dictionary, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Dictionary, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Dictionary, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::DidSet, double>> {
+    static void from_json(const json & j, std::variant<quicktype::DidSet, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::DidSet, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Dynamic, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Dynamic, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Dynamic, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Elif, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Elif, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Elif, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Empty, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Empty, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Empty, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::EncodeQuickType, double>> {
+    static void from_json(const json & j, std::variant<quicktype::EncodeQuickType, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::EncodeQuickType, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Event, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Event, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Event, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Except, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Except, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Except, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Exception, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Exception, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Exception, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Exposing, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Exposing, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Exposing, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Extends, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Extends, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Extends, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Extension, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Extension, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Extension, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Fallthrough, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Fallthrough, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Fallthrough, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Fileprivate, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Fileprivate, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Fileprivate, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Finally, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Finally, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Finally, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Fixed, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Fixed, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Fixed, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::UnionBoolBool, double>> {
+    static void from_json(const json & j, std::variant<quicktype::UnionBoolBool, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::UnionBoolBool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Foreach, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Foreach, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Foreach, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::From, double>> {
+    static void from_json(const json & j, std::variant<quicktype::From, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::From, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FromJson, double>> {
+    static void from_json(const json & j, std::variant<quicktype::FromJson, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::FromJson, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Func, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Func, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Func, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Function, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Function, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Function, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Get, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Get, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Get, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Global, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Global, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Global, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Go, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Go, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Go, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Guard, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Guard, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Guard, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::HasOwnProperty, double>> {
+    static void from_json(const json & j, std::variant<quicktype::HasOwnProperty, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::HasOwnProperty, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Id, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Id, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Id, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Imaginery, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Imaginery, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Imaginery, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Imp, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Imp, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Imp, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Implements, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Implements, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Implements, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Implicit, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Implicit, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Implicit, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::In, double>> {
+    static void from_json(const json & j, std::variant<quicktype::In, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::In, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Indirect, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Indirect, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Indirect, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Infix, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Infix, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Infix, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Init, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Init, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Init, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Inout, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Inout, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Inout, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Instanceof, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Instanceof, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Instanceof, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Interface, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Interface, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Interface, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Internal, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Internal, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Internal, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Is, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Is, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Is, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Iterable, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Iterable, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Iterable, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Jdec, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Jdec, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Jdec, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Jenc, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Jenc, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Jenc, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Jpipe, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Jpipe, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Jpipe, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Json, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Json, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Json, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::JsonConverter, double>> {
+    static void from_json(const json & j, std::variant<quicktype::JsonConverter, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::JsonConverter, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::JsonSerializer, double>> {
+    static void from_json(const json & j, std::variant<quicktype::JsonSerializer, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::JsonSerializer, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::JsonToken, double>> {
+    static void from_json(const json & j, std::variant<quicktype::JsonToken, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::JsonToken, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::JsonWriter, double>> {
+    static void from_json(const json & j, std::variant<quicktype::JsonWriter, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::JsonWriter, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Lambda, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Lambda, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Lambda, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Lazy, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Lazy, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Lazy, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Left, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Left, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Left, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Let, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Let, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Let, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::List, double>> {
+    static void from_json(const json & j, std::variant<quicktype::List, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::List, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Lock, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Lock, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Lock, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Map, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Map, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Map, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::MetadataPropertyHandling, double>> {
+    static void from_json(const json & j, std::variant<quicktype::MetadataPropertyHandling, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::MetadataPropertyHandling, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Mutating, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Mutating, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Mutating, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Native, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Native, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Native, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Newtonsoft, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Newtonsoft, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Newtonsoft, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Nil, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Nil, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Nil, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::No, double>> {
+    static void from_json(const json & j, std::variant<quicktype::No, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::No, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Nonatomic, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Nonatomic, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Nonatomic, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::None, double>> {
+    static void from_json(const json & j, std::variant<quicktype::None, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::None, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Nonlocal, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Nonlocal, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Nonlocal, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Nonmutating, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Nonmutating, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Nonmutating, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::NsString, double>> {
+    static void from_json(const json & j, std::variant<quicktype::NsString, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::NsString, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Null, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Null, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Null, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Number, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Number, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Number, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Object, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Object, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Object, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Of, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Of, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Of, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Oneway, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Oneway, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Oneway, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Open, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Open, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Open, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Optional, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Optional, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Optional, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Out, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Out, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Out, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Package, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Package, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Package, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Params, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Params, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Params, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Pass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Pass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Pass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Port, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Port, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Port, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Postfix, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Postfix, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Postfix, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Precedence, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Precedence, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Precedence, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Prefix, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Prefix, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Prefix, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Print, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Print, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Print, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Printf, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Printf, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Printf, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Protocol, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Protocol, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Protocol, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::BoolClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::BoolClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::BoolClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ClassClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::ClassClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::ClassClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::FalseClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::FalseClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::FalseClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::TrueClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::TrueClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::TrueClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Quicktype, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Quicktype, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Quicktype, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Raise, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Raise, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Raise, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Range, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Range, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Range, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Readonly, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Readonly, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Readonly, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Ref, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Ref, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Ref, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Repeat, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Repeat, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Repeat, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Require, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Require, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Require, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Required, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Required, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Required, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Restrict, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Restrict, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Restrict, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Retain, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Retain, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Retain, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Rethrows, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Rethrows, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Rethrows, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Right, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Right, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Right, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Sbyte, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Sbyte, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Sbyte, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Sealed, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Sealed, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Sealed, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Sel, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Sel, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Sel, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Select, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Select, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Select, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Self, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Self, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Self, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Serialize, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Serialize, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Serialize, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Set, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Set, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Set, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Stackalloc, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Stackalloc, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Stackalloc, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Strictfp, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Strictfp, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Strictfp, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::String, double>> {
+    static void from_json(const json & j, std::variant<quicktype::String, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::String, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Subscript, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Subscript, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Subscript, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Super, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Super, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Super, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Symbol, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Symbol, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Symbol, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::System, double>> {
+    static void from_json(const json & j, std::variant<quicktype::System, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::System, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Then, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Then, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Then, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Throws, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Throws, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Throws, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ToJson, double>> {
+    static void from_json(const json & j, std::variant<quicktype::ToJson, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::ToJson, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::TopLevelClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::TopLevelClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::TopLevelClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Alignas, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Alignas, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Alignas, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Alignof, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Alignof, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Alignof, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::And, double>> {
+    static void from_json(const json & j, std::variant<quicktype::And, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::And, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::AndEq, double>> {
+    static void from_json(const json & j, std::variant<quicktype::AndEq, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::AndEq, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::AnyClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::AnyClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::AnyClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Asm, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Asm, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Asm, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::AtomicCancel, double>> {
+    static void from_json(const json & j, std::variant<quicktype::AtomicCancel, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::AtomicCancel, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::AtomicCommit, double>> {
+    static void from_json(const json & j, std::variant<quicktype::AtomicCommit, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::AtomicCommit, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::AtomicNoexcept, double>> {
+    static void from_json(const json & j, std::variant<quicktype::AtomicNoexcept, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::AtomicNoexcept, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Auto, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Auto, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Auto, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Bitand, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Bitand, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Bitand, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Bitor, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Bitor, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Bitor, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Bool, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Bool, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Bool, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Break, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Break, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Break, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Case, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Case, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Case, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Catch, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Catch, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Catch, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Char, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Char, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Char, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Char16T, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Char16T, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Char16T, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Char32T, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Char32T, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Char32T, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Class, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Class, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Class, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CoAwait, double>> {
+    static void from_json(const json & j, std::variant<quicktype::CoAwait, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::CoAwait, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CoReturn, double>> {
+    static void from_json(const json & j, std::variant<quicktype::CoReturn, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::CoReturn, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::CoYield, double>> {
+    static void from_json(const json & j, std::variant<quicktype::CoYield, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::CoYield, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Compl, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Compl, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Compl, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Concept, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Concept, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Concept, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Const, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Const, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Const, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ConstCast, double>> {
+    static void from_json(const json & j, std::variant<quicktype::ConstCast, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::ConstCast, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Constexpr, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Constexpr, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Constexpr, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Continue, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Continue, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Continue, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Decltype, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Decltype, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Decltype, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Default, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Default, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Default, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Delete, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Delete, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Delete, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Do, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Do, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Do, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Double, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Double, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Double, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::DynamicCast, double>> {
+    static void from_json(const json & j, std::variant<quicktype::DynamicCast, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::DynamicCast, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Else, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Else, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Else, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Enum, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Enum, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Enum, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Explicit, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Explicit, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Explicit, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Export, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Export, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Export, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Extern, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Extern, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Extern, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::False, double>> {
+    static void from_json(const json & j, std::variant<quicktype::False, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::False, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Final, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Final, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Final, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Float, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Float, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Float, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::For, double>> {
+    static void from_json(const json & j, std::variant<quicktype::For, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::For, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Friend, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Friend, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Friend, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Goto, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Goto, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Goto, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::If, double>> {
+    static void from_json(const json & j, std::variant<quicktype::If, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::If, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Import, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Import, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Import, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Inline, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Inline, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Inline, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Int, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Int, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Int, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Long, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Long, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Long, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Module, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Module, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Module, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Mutable, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Mutable, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Mutable, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Namespace, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Namespace, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Namespace, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::New, double>> {
+    static void from_json(const json & j, std::variant<quicktype::New, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::New, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Noexcept, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Noexcept, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Noexcept, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::NoneClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::NoneClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::NoneClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Not, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Not, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Not, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::NotEq, double>> {
+    static void from_json(const json & j, std::variant<quicktype::NotEq, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::NotEq, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::NullClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::NullClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::NullClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Nullptr, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Nullptr, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Nullptr, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Operator, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Operator, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Operator, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Or, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Or, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Or, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::OrEq, double>> {
+    static void from_json(const json & j, std::variant<quicktype::OrEq, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::OrEq, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Override, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Override, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Override, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Private, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Private, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Private, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Protected, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Protected, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Protected, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ProtocolClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::ProtocolClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::ProtocolClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Public, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Public, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Public, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Register, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Register, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Register, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ReinterpretCast, double>> {
+    static void from_json(const json & j, std::variant<quicktype::ReinterpretCast, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::ReinterpretCast, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Requires, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Requires, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Requires, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Return, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Return, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Return, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::SelfClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::SelfClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::SelfClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Short, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Short, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Short, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Signed, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Signed, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Signed, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Sizeof, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Sizeof, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Sizeof, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Static, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Static, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Static, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::StaticAssert, double>> {
+    static void from_json(const json & j, std::variant<quicktype::StaticAssert, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::StaticAssert, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::StaticCast, double>> {
+    static void from_json(const json & j, std::variant<quicktype::StaticCast, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::StaticCast, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Struct, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Struct, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Struct, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Switch, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Switch, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Switch, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Synchronized, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Synchronized, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Synchronized, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Template, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Template, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Template, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::This, double>> {
+    static void from_json(const json & j, std::variant<quicktype::This, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::This, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::ThreadLocal, double>> {
+    static void from_json(const json & j, std::variant<quicktype::ThreadLocal, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::ThreadLocal, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Throw, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Throw, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Throw, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::True, double>> {
+    static void from_json(const json & j, std::variant<quicktype::True, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::True, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Try, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Try, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Try, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::TypeClass, double>> {
+    static void from_json(const json & j, std::variant<quicktype::TypeClass, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::TypeClass, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Typedef, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Typedef, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Typedef, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Typeid, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Typeid, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Typeid, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Typename, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Typename, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Typename, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Union, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Union, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Union, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Unsigned, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Unsigned, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Unsigned, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Using, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Using, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Using, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Virtual, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Virtual, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Virtual, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Void, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Void, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Void, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Volatile, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Volatile, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Volatile, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::WcharT, double>> {
+    static void from_json(const json & j, std::variant<quicktype::WcharT, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::WcharT, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::While, double>> {
+    static void from_json(const json & j, std::variant<quicktype::While, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::While, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Xor, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Xor, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Xor, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::XorEq, double>> {
+    static void from_json(const json & j, std::variant<quicktype::XorEq, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::XorEq, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Transient, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Transient, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Transient, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Type, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Type, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Type, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Typealias, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Typealias, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Typealias, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Typeof, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Typeof, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Typeof, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Uint, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Uint, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Uint, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Ulong, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Ulong, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Ulong, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Unchecked, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Unchecked, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Unchecked, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Undefined, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Undefined, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Undefined, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Unowned, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Unowned, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Unowned, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Unsafe, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Unsafe, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Unsafe, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Ushort, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Ushort, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Ushort, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Var, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Var, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Var, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Weak, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Weak, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Weak, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Where, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Where, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Where, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::WillSet, double>> {
+    static void from_json(const json & j, std::variant<quicktype::WillSet, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::WillSet, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::With, double>> {
+    static void from_json(const json & j, std::variant<quicktype::With, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::With, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Yes, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Yes, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Yes, double> & x);
+};
+
+template <>
+struct adl_serializer<std::variant<quicktype::Yield, double>> {
+    static void from_json(const json & j, std::variant<quicktype::Yield, double> & x);
+    static void to_json(json & j, const std::variant<quicktype::Yield, double> & x);
+};
+}
+namespace quicktype {
+    inline void from_json(const json & j, Abstract& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Abstract & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Any& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Any & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Array& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Array & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, As& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const As & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Assert& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Assert & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Associatedtype& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Associatedtype & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Associativity& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Associativity & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Async& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Async & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Atomic& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Atomic & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Await& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Await & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Base& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Base & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Boolean& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Boolean & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Bycopy& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Bycopy & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Byref& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Byref & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Byte& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Byte & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Chan& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Chan & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Checked& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Checked & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Complex& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Complex & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Console& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Console & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Constructor& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Constructor & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Convenience& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Convenience & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Convert& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Convert & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Converter& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Converter & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Date& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Date & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, DateParseHandling& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const DateParseHandling & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Debugger& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Debugger & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Decimal& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Decimal & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Declare& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Declare & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, DecodeString& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const DecodeString & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Def& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Def & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Defer& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Defer & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Deinit& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Deinit & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Del& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Del & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Delegate& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Delegate & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Dict& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Dict & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Dictionary& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Dictionary & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, DidSet& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const DidSet & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Dynamic& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Dynamic & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Elif& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Elif & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Empty& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Empty & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, EncodeQuickType& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const EncodeQuickType & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Event& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Event & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Except& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Except & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Exception& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Exception & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Exposing& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Exposing & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Extends& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Extends & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Extension& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Extension & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Fallthrough& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Fallthrough & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Fileprivate& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Fileprivate & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Finally& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Finally & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Fixed& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Fixed & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, UnionBoolBool& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const UnionBoolBool & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Foreach& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Foreach & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, From& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const From & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, FromJson& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const FromJson & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Func& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Func & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Function& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Function & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Get& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Get & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Global& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Global & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Go& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Go & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Guard& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Guard & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, HasOwnProperty& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const HasOwnProperty & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Id& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Id & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Imaginery& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Imaginery & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Imp& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Imp & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Implements& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Implements & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Implicit& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Implicit & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, In& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const In & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Indirect& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Indirect & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Infix& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Infix & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Init& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Init & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Inout& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Inout & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Instanceof& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Instanceof & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Interface& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Interface & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Internal& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Internal & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Is& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Is & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Iterable& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Iterable & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Jdec& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Jdec & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Jenc& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Jenc & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Jpipe& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Jpipe & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Json& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Json & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, JsonConverter& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const JsonConverter & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, JsonSerializer& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const JsonSerializer & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, JsonToken& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const JsonToken & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, JsonWriter& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const JsonWriter & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Lambda& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Lambda & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Lazy& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Lazy & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Left& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Left & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Let& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Let & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, List& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const List & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Lock& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Lock & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Map& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Map & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, MetadataPropertyHandling& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const MetadataPropertyHandling & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Mutating& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Mutating & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Native& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Native & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Newtonsoft& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Newtonsoft & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Nil& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Nil & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, No& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const No & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Nonatomic& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Nonatomic & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, None& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const None & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Nonlocal& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Nonlocal & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Nonmutating& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Nonmutating & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, NsString& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const NsString & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Null& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Null & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Number& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Number & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Object& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Object & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Of& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Of & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Oneway& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Oneway & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Open& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Open & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Optional& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Optional & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Out& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Out & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Package& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Package & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Params& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Params & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Pass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Pass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Port& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Port & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Postfix& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Postfix & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Precedence& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Precedence & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Prefix& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Prefix & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Print& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Print & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Printf& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Printf & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Protocol& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Protocol & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, BoolClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const BoolClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, ClassClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const ClassClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, FalseClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const FalseClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, TrueClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const TrueClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Quicktype& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Quicktype & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Raise& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Raise & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Range& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Range & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Readonly& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Readonly & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Ref& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Ref & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Repeat& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Repeat & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Require& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Require & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Required& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Required & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Restrict& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Restrict & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Retain& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Retain & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Rethrows& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Rethrows & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Right& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Right & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Sbyte& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Sbyte & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Sealed& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Sealed & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Sel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Sel & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Select& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Select & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Self& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Self & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Serialize& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Serialize & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Set& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Set & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Stackalloc& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Stackalloc & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Strictfp& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Strictfp & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, String& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const String & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Subscript& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Subscript & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Super& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Super & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Symbol& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Symbol & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, System& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const System & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Then& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Then & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Throws& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Throws & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, ToJson& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const ToJson & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, TopLevelClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const TopLevelClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Alignas& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Alignas & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Alignof& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Alignof & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, And& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const And & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, AndEq& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const AndEq & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, AnyClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const AnyClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Asm& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Asm & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, AtomicCancel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const AtomicCancel & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, AtomicCommit& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const AtomicCommit & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, AtomicNoexcept& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const AtomicNoexcept & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Auto& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Auto & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Bitand& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Bitand & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Bitor& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Bitor & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Bool& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Bool & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Break& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Break & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Case& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Case & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Catch& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Catch & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Char& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Char & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Char16T& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Char16T & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Char32T& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Char32T & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Class& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Class & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, CoAwait& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const CoAwait & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, CoReturn& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const CoReturn & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, CoYield& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const CoYield & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Compl& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Compl & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Concept& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Concept & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Const& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Const & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, ConstCast& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const ConstCast & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Constexpr& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Constexpr & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Continue& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Continue & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Decltype& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Decltype & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Default& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Default & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Delete& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Delete & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Do& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Do & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Double& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Double & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, DynamicCast& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const DynamicCast & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Else& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Else & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Enum& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Enum & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Explicit& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Explicit & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Export& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Export & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Extern& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Extern & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, False& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const False & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Final& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Final & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Float& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Float & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, For& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const For & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Friend& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Friend & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Goto& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Goto & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, If& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const If & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Import& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Import & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Inline& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Inline & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Int& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Int & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Long& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Long & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Module& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Module & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Mutable& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Mutable & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Namespace& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Namespace & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, New& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const New & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Noexcept& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Noexcept & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, NoneClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const NoneClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Not& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Not & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, NotEq& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const NotEq & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, NullClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const NullClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Nullptr& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Nullptr & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Operator& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Operator & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Or& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Or & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, OrEq& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const OrEq & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Override& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Override & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Private& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Private & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Protected& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Protected & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, ProtocolClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const ProtocolClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Public& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Public & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Register& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Register & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, ReinterpretCast& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const ReinterpretCast & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Requires& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Requires & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Return& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Return & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, SelfClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const SelfClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Short& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Short & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Signed& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Signed & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Sizeof& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Sizeof & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Static& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Static & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, StaticAssert& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const StaticAssert & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, StaticCast& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const StaticCast & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Struct& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Struct & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Switch& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Switch & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Synchronized& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Synchronized & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Template& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Template & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, This& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const This & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, ThreadLocal& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const ThreadLocal & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Throw& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Throw & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, True& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const True & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Try& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Try & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, TypeClass& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const TypeClass & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Typedef& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Typedef & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Typeid& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Typeid & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Typename& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Typename & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Union& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Union & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Unsigned& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Unsigned & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Using& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Using & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Virtual& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Virtual & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Void& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Void & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Volatile& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Volatile & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, WcharT& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const WcharT & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, While& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const While & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Xor& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Xor & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, XorEq& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const XorEq & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Transient& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Transient & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Type& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Type & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Typealias& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Typealias & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Typeof& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Typeof & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Uint& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Uint & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Ulong& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Ulong & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Unchecked& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Unchecked & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Undefined& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Undefined & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Unowned& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Unowned & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Unsafe& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Unsafe & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Ushort& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Ushort & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Var& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Var & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Weak& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Weak & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Where& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Where & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, WillSet& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const WillSet & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, With& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const With & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Yes& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Yes & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, Yield& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        (void)j;
+        (void)x;
+    }
+
+    inline void to_json(json & j, const Yield & x) {
+        j = json::object();
+        (void)x;
+    }
+
+    inline void from_json(const json & j, TopLevel& x) {
+        if (!j.is_object()) throw std::runtime_error("Expected object");
+        x.set_empty(get_stack_optional<std::variant<Empty, double>>(j, "_"));
+        x.set_purple_bool(get_stack_optional<std::variant<BoolClass, double>>(j, "_Bool"));
+        x.set_complex(get_stack_optional<std::variant<Complex, double>>(j, "_Complex"));
+        x.set_imaginery(get_stack_optional<std::variant<Imaginery, double>>(j, "_Imaginery"));
+        x.set_abstract(get_stack_optional<std::variant<Abstract, double>>(j, "abstract"));
+        x.set_top_level_alignas(get_stack_optional<std::variant<Alignas, double>>(j, "alignas"));
+        x.set_top_level_alignof(get_stack_optional<std::variant<Alignof, double>>(j, "alignof"));
+        x.set_top_level_and(get_stack_optional<std::variant<And, double>>(j, "and"));
+        x.set_top_level_and_eq(get_stack_optional<std::variant<AndEq, double>>(j, "and_eq"));
+        x.set_top_level_any(get_stack_optional<std::variant<AnyClass, double>>(j, "any"));
+        x.set_any(get_stack_optional<std::variant<Any, double>>(j, "Any"));
+        x.set_array(get_stack_optional<std::variant<Array, double>>(j, "array"));
+        x.set_as(get_stack_optional<std::variant<As, double>>(j, "as"));
+        x.set_top_level_asm(get_stack_optional<std::variant<Asm, double>>(j, "asm"));
+        x.set_assert(get_stack_optional<std::variant<Assert, double>>(j, "assert"));
+        x.set_associatedtype(get_stack_optional<std::variant<Associatedtype, double>>(j, "associatedtype"));
+        x.set_associativity(get_stack_optional<std::variant<Associativity, double>>(j, "associativity"));
+        x.set_async(get_stack_optional<std::variant<Async, double>>(j, "async"));
+        x.set_atomic(get_stack_optional<std::variant<Atomic, double>>(j, "atomic"));
+        x.set_top_level_atomic_cancel(get_stack_optional<std::variant<AtomicCancel, double>>(j, "atomic_cancel"));
+        x.set_top_level_atomic_commit(get_stack_optional<std::variant<AtomicCommit, double>>(j, "atomic_commit"));
+        x.set_top_level_atomic_noexcept(get_stack_optional<std::variant<AtomicNoexcept, double>>(j, "atomic_noexcept"));
+        x.set_top_level_auto(get_stack_optional<std::variant<Auto, double>>(j, "auto"));
+        x.set_await(get_stack_optional<std::variant<Await, double>>(j, "await"));
+        x.set_base(get_stack_optional<std::variant<Base, double>>(j, "base"));
+        x.set_top_level_bitand(get_stack_optional<std::variant<Bitand, double>>(j, "bitand"));
+        x.set_top_level_bitor(get_stack_optional<std::variant<Bitor, double>>(j, "bitor"));
+        x.set_top_level_bool(get_stack_optional<std::variant<Bool, double>>(j, "BOOL"));
+        x.set_fluffy_bool(get_stack_optional<std::variant<UnionBoolBool, double>>(j, "bool"));
+        x.set_boolean(get_stack_optional<std::variant<Boolean, double>>(j, "boolean"));
+        x.set_top_level_break(get_stack_optional<std::variant<Break, double>>(j, "break"));
+        x.set_bycopy(get_stack_optional<std::variant<Bycopy, double>>(j, "bycopy"));
+        x.set_byref(get_stack_optional<std::variant<Byref, double>>(j, "byref"));
+        x.set_byte(get_stack_optional<std::variant<Byte, double>>(j, "byte"));
+        x.set_top_level_case(get_stack_optional<std::variant<Case, double>>(j, "case"));
+        x.set_top_level_catch(get_stack_optional<std::variant<Catch, double>>(j, "catch"));
+        x.set_chan(get_stack_optional<std::variant<Chan, double>>(j, "chan"));
+        x.set_top_level_char(get_stack_optional<std::variant<Char, double>>(j, "char"));
+        x.set_top_level_char16_t(get_stack_optional<std::variant<Char16T, double>>(j, "char16_t"));
+        x.set_top_level_char32_t(get_stack_optional<std::variant<Char32T, double>>(j, "char32_t"));
+        x.set_checked(get_stack_optional<std::variant<Checked, double>>(j, "checked"));
+        x.set_purple_class(get_stack_optional<std::variant<ClassClass, double>>(j, "class"));
+        x.set_top_level_class(get_stack_optional<std::variant<Class, double>>(j, "Class"));
+        x.set_top_level_co_await(get_stack_optional<std::variant<CoAwait, double>>(j, "co_await"));
+        x.set_top_level_co_return(get_stack_optional<std::variant<CoReturn, double>>(j, "co_return"));
+        x.set_top_level_co_yield(get_stack_optional<std::variant<CoYield, double>>(j, "co_yield"));
+        x.set_top_level_compl(get_stack_optional<std::variant<Compl, double>>(j, "compl"));
+        x.set_top_level_concept(get_stack_optional<std::variant<Concept, double>>(j, "concept"));
+        x.set_console(get_stack_optional<std::variant<Console, double>>(j, "console"));
+        x.set_top_level_const(get_stack_optional<std::variant<Const, double>>(j, "const"));
+        x.set_top_level_const_cast(get_stack_optional<std::variant<ConstCast, double>>(j, "const_cast"));
+        x.set_top_level_constexpr(get_stack_optional<std::variant<Constexpr, double>>(j, "constexpr"));
+        x.set_constructor(get_stack_optional<std::variant<Constructor, double>>(j, "constructor"));
+        x.set_top_level_continue(get_stack_optional<std::variant<Continue, double>>(j, "continue"));
+        x.set_convenience(get_stack_optional<std::variant<Convenience, double>>(j, "convenience"));
+        x.set_convert(get_stack_optional<std::variant<Convert, double>>(j, "convert"));
+        x.set_converter(get_stack_optional<std::variant<Converter, double>>(j, "converter"));
+        x.set_date(get_stack_optional<std::variant<Date, double>>(j, "date"));
+        x.set_date_parse_handling(get_stack_optional<std::variant<DateParseHandling, double>>(j, "date_parse_handling"));
+        x.set_debugger(get_stack_optional<std::variant<Debugger, double>>(j, "debugger"));
+        x.set_decimal(get_stack_optional<std::variant<Decimal, double>>(j, "decimal"));
+        x.set_declare(get_stack_optional<std::variant<Declare, double>>(j, "declare"));
+        x.set_top_level_decltype(get_stack_optional<std::variant<Decltype, double>>(j, "decltype"));
+        x.set_decode_string(get_stack_optional<std::variant<DecodeString, double>>(j, "decode_string"));
+        x.set_def(get_stack_optional<std::variant<Def, double>>(j, "def"));
+        x.set_top_level_default(get_stack_optional<std::variant<Default, double>>(j, "default"));
+        x.set_defer(get_stack_optional<std::variant<Defer, double>>(j, "defer"));
+        x.set_deinit(get_stack_optional<std::variant<Deinit, double>>(j, "deinit"));
+        x.set_del(get_stack_optional<std::variant<Del, double>>(j, "del"));
+        x.set_delegate(get_stack_optional<std::variant<Delegate, double>>(j, "delegate"));
+        x.set_top_level_delete(get_stack_optional<std::variant<Delete, double>>(j, "delete"));
+        x.set_dict(get_stack_optional<std::variant<Dict, double>>(j, "dict"));
+        x.set_dictionary(get_stack_optional<std::variant<Dictionary, double>>(j, "dictionary"));
+        x.set_did_set(get_stack_optional<std::variant<DidSet, double>>(j, "didSet"));
+        x.set_top_level_do(get_stack_optional<std::variant<Do, double>>(j, "do"));
+        x.set_top_level_double(get_stack_optional<std::variant<Double, double>>(j, "double"));
+        x.set_dummy(get_stack_optional<double>(j, "dummy"));
+        x.set_dynamic(get_stack_optional<std::variant<Dynamic, double>>(j, "dynamic"));
+        x.set_top_level_dynamic_cast(get_stack_optional<std::variant<DynamicCast, double>>(j, "dynamic_cast"));
+        x.set_elif(get_stack_optional<std::variant<Elif, double>>(j, "elif"));
+        x.set_top_level_else(get_stack_optional<std::variant<Else, double>>(j, "else"));
+        x.set_encode_quick_type(get_stack_optional<std::variant<EncodeQuickType, double>>(j, "encode_quick_type"));
+        x.set_top_level_enum(get_stack_optional<std::variant<Enum, double>>(j, "enum"));
+        x.set_event(get_stack_optional<std::variant<Event, double>>(j, "event"));
+        x.set_except(get_stack_optional<std::variant<Except, double>>(j, "except"));
+        x.set_exception(get_stack_optional<std::variant<Exception, double>>(j, "exception"));
+        x.set_top_level_explicit(get_stack_optional<std::variant<Explicit, double>>(j, "explicit"));
+        x.set_top_level_export(get_stack_optional<std::variant<Export, double>>(j, "export"));
+        x.set_exposing(get_stack_optional<std::variant<Exposing, double>>(j, "exposing"));
+        x.set_extends(get_stack_optional<std::variant<Extends, double>>(j, "extends"));
+        x.set_extension(get_stack_optional<std::variant<Extension, double>>(j, "extension"));
+        x.set_top_level_extern(get_stack_optional<std::variant<Extern, double>>(j, "extern"));
+        x.set_fallthrough(get_stack_optional<std::variant<Fallthrough, double>>(j, "fallthrough"));
+        x.set_purple_false(get_stack_optional<std::variant<FalseClass, double>>(j, "false"));
+        x.set_top_level_false(get_stack_optional<std::variant<False, double>>(j, "False"));
+        x.set_fileprivate(get_stack_optional<std::variant<Fileprivate, double>>(j, "fileprivate"));
+        x.set_top_level_final(get_stack_optional<std::variant<Final, double>>(j, "final"));
+        x.set_finally(get_stack_optional<std::variant<Finally, double>>(j, "finally"));
+        x.set_fixed(get_stack_optional<std::variant<Fixed, double>>(j, "fixed"));
+        x.set_top_level_float(get_stack_optional<std::variant<Float, double>>(j, "float"));
+        x.set_top_level_for(get_stack_optional<std::variant<For, double>>(j, "for"));
+        x.set_foreach(get_stack_optional<std::variant<Foreach, double>>(j, "foreach"));
+        x.set_top_level_friend(get_stack_optional<std::variant<Friend, double>>(j, "friend"));
+        x.set_from(get_stack_optional<std::variant<From, double>>(j, "from"));
+        x.set_from_json(get_stack_optional<std::variant<FromJson, double>>(j, "from_json"));
+        x.set_func(get_stack_optional<std::variant<Func, double>>(j, "func"));
+        x.set_function(get_stack_optional<std::variant<Function, double>>(j, "function"));
+        x.set_get(get_stack_optional<std::variant<Get, double>>(j, "get"));
+        x.set_global(get_stack_optional<std::variant<Global, double>>(j, "global"));
+        x.set_go(get_stack_optional<std::variant<Go, double>>(j, "go"));
+        x.set_top_level_goto(get_stack_optional<std::variant<Goto, double>>(j, "goto"));
+        x.set_guard(get_stack_optional<std::variant<Guard, double>>(j, "guard"));
+        x.set_has_own_property(get_stack_optional<std::variant<HasOwnProperty, double>>(j, "hasOwnProperty"));
+        x.set_id(get_stack_optional<std::variant<Id, double>>(j, "id"));
+        x.set_top_level_if(get_stack_optional<std::variant<If, double>>(j, "if"));
+        x.set_imp(get_stack_optional<std::variant<Imp, double>>(j, "IMP"));
+        x.set_implements(get_stack_optional<std::variant<Implements, double>>(j, "implements"));
+        x.set_implicit(get_stack_optional<std::variant<Implicit, double>>(j, "implicit"));
+        x.set_top_level_import(get_stack_optional<std::variant<Import, double>>(j, "import"));
+        x.set_in(get_stack_optional<std::variant<In, double>>(j, "in"));
+        x.set_indirect(get_stack_optional<std::variant<Indirect, double>>(j, "indirect"));
+        x.set_infix(get_stack_optional<std::variant<Infix, double>>(j, "infix"));
+        x.set_init(get_stack_optional<std::variant<Init, double>>(j, "init"));
+        x.set_top_level_inline(get_stack_optional<std::variant<Inline, double>>(j, "inline"));
+        x.set_inout(get_stack_optional<std::variant<Inout, double>>(j, "inout"));
+        x.set_instanceof(get_stack_optional<std::variant<Instanceof, double>>(j, "instanceof"));
+        x.set_top_level_int(get_stack_optional<std::variant<Int, double>>(j, "int"));
+        x.set_interface(get_stack_optional<std::variant<Interface, double>>(j, "interface"));
+        x.set_internal(get_stack_optional<std::variant<Internal, double>>(j, "internal"));
+        x.set_is(get_stack_optional<std::variant<Is, double>>(j, "is"));
+        x.set_iterable(get_stack_optional<std::variant<Iterable, double>>(j, "iterable"));
+        x.set_jdec(get_stack_optional<std::variant<Jdec, double>>(j, "jdec"));
+        x.set_jenc(get_stack_optional<std::variant<Jenc, double>>(j, "jenc"));
+        x.set_jpipe(get_stack_optional<std::variant<Jpipe, double>>(j, "jpipe"));
+        x.set_json(get_stack_optional<std::variant<Json, double>>(j, "json"));
+        x.set_json_converter(get_stack_optional<std::variant<JsonConverter, double>>(j, "json_converter"));
+        x.set_json_serializer(get_stack_optional<std::variant<JsonSerializer, double>>(j, "json_serializer"));
+        x.set_json_token(get_stack_optional<std::variant<JsonToken, double>>(j, "json_token"));
+        x.set_json_writer(get_stack_optional<std::variant<JsonWriter, double>>(j, "json_writer"));
+        x.set_lambda(get_stack_optional<std::variant<Lambda, double>>(j, "lambda"));
+        x.set_lazy(get_stack_optional<std::variant<Lazy, double>>(j, "lazy"));
+        x.set_left(get_stack_optional<std::variant<Left, double>>(j, "left"));
+        x.set_let(get_stack_optional<std::variant<Let, double>>(j, "let"));
+        x.set_list(get_stack_optional<std::variant<List, double>>(j, "list"));
+        x.set_lock(get_stack_optional<std::variant<Lock, double>>(j, "lock"));
+        x.set_top_level_long(get_stack_optional<std::variant<Long, double>>(j, "long"));
+        x.set_map(get_stack_optional<std::variant<Map, double>>(j, "map"));
+        x.set_metadata_property_handling(get_stack_optional<std::variant<MetadataPropertyHandling, double>>(j, "metadata_property_handling"));
+        x.set_top_level_module(get_stack_optional<std::variant<Module, double>>(j, "module"));
+        x.set_top_level_mutable(get_stack_optional<std::variant<Mutable, double>>(j, "mutable"));
+        x.set_mutating(get_stack_optional<std::variant<Mutating, double>>(j, "mutating"));
+        x.set_top_level_namespace(get_stack_optional<std::variant<Namespace, double>>(j, "namespace"));
+        x.set_native(get_stack_optional<std::variant<Native, double>>(j, "native"));
+        x.set_top_level_new(get_stack_optional<std::variant<New, double>>(j, "new"));
+        x.set_newtonsoft(get_stack_optional<std::variant<Newtonsoft, double>>(j, "newtonsoft"));
+        x.set_nil(get_stack_optional<std::variant<Nil, double>>(j, "nil"));
+        x.set_no(get_stack_optional<std::variant<No, double>>(j, "NO"));
+        x.set_top_level_noexcept(get_stack_optional<std::variant<Noexcept, double>>(j, "noexcept"));
+        x.set_nonatomic(get_stack_optional<std::variant<Nonatomic, double>>(j, "nonatomic"));
+        x.set_top_level_none(get_stack_optional<std::variant<NoneClass, double>>(j, "none"));
+        x.set_none(get_stack_optional<std::variant<None, double>>(j, "None"));
+        x.set_nonlocal(get_stack_optional<std::variant<Nonlocal, double>>(j, "nonlocal"));
+        x.set_nonmutating(get_stack_optional<std::variant<Nonmutating, double>>(j, "nonmutating"));
+        x.set_top_level_not(get_stack_optional<std::variant<Not, double>>(j, "not"));
+        x.set_top_level_not_eq(get_stack_optional<std::variant<NotEq, double>>(j, "not_eq"));
+        x.set_ns_string(get_stack_optional<std::variant<NsString, double>>(j, "NSString"));
+        x.set_null(get_stack_optional<std::variant<Null, double>>(j, "NULL"));
+        x.set_top_level_null(get_stack_optional<std::variant<NullClass, double>>(j, "null"));
+        x.set_top_level_nullptr(get_stack_optional<std::variant<Nullptr, double>>(j, "nullptr"));
+        x.set_number(get_stack_optional<std::variant<Number, double>>(j, "number"));
+        x.set_object(get_stack_optional<std::variant<Object, double>>(j, "object"));
+        x.set_of(get_stack_optional<std::variant<Of, double>>(j, "of"));
+        x.set_oneway(get_stack_optional<std::variant<Oneway, double>>(j, "oneway"));
+        x.set_open(get_stack_optional<std::variant<Open, double>>(j, "open"));
+        x.set_top_level_operator(get_stack_optional<std::variant<Operator, double>>(j, "operator"));
+        x.set_optional(get_stack_optional<std::variant<Optional, double>>(j, "optional"));
+        x.set_top_level_or(get_stack_optional<std::variant<Or, double>>(j, "or"));
+        x.set_top_level_or_eq(get_stack_optional<std::variant<OrEq, double>>(j, "or_eq"));
+        x.set_out(get_stack_optional<std::variant<Out, double>>(j, "out"));
+        x.set_top_level_override(get_stack_optional<std::variant<Override, double>>(j, "override"));
+        x.set_package(get_stack_optional<std::variant<Package, double>>(j, "package"));
+        x.set_params(get_stack_optional<std::variant<Params, double>>(j, "params"));
+        x.set_pass(get_stack_optional<std::variant<Pass, double>>(j, "pass"));
+        x.set_port(get_stack_optional<std::variant<Port, double>>(j, "port"));
+        x.set_postfix(get_stack_optional<std::variant<Postfix, double>>(j, "postfix"));
+        x.set_precedence(get_stack_optional<std::variant<Precedence, double>>(j, "precedence"));
+        x.set_prefix(get_stack_optional<std::variant<Prefix, double>>(j, "prefix"));
+        x.set_print(get_stack_optional<std::variant<Print, double>>(j, "print"));
+        x.set_printf(get_stack_optional<std::variant<Printf, double>>(j, "printf"));
+        x.set_top_level_private(get_stack_optional<std::variant<Private, double>>(j, "private"));
+        x.set_top_level_protected(get_stack_optional<std::variant<Protected, double>>(j, "protected"));
+        x.set_protocol(get_stack_optional<std::variant<Protocol, double>>(j, "Protocol"));
+        x.set_top_level_protocol(get_stack_optional<std::variant<ProtocolClass, double>>(j, "protocol"));
+        x.set_top_level_public(get_stack_optional<std::variant<Public, double>>(j, "public"));
+        x.set_quicktype(get_stack_optional<std::variant<Quicktype, double>>(j, "quicktype"));
+        x.set_raise(get_stack_optional<std::variant<Raise, double>>(j, "raise"));
+        x.set_range(get_stack_optional<std::variant<Range, double>>(j, "range"));
+        x.set_readonly(get_stack_optional<std::variant<Readonly, double>>(j, "readonly"));
+        x.set_ref(get_stack_optional<std::variant<Ref, double>>(j, "ref"));
+        x.set_top_level_register(get_stack_optional<std::variant<Register, double>>(j, "register"));
+        x.set_top_level_reinterpret_cast(get_stack_optional<std::variant<ReinterpretCast, double>>(j, "reinterpret_cast"));
+        x.set_repeat(get_stack_optional<std::variant<Repeat, double>>(j, "repeat"));
+        x.set_require(get_stack_optional<std::variant<Require, double>>(j, "require"));
+        x.set_required(get_stack_optional<std::variant<Required, double>>(j, "required"));
+        x.set_top_level_requires(get_stack_optional<std::variant<Requires, double>>(j, "requires"));
+        x.set_restrict(get_stack_optional<std::variant<Restrict, double>>(j, "restrict"));
+        x.set_retain(get_stack_optional<std::variant<Retain, double>>(j, "retain"));
+        x.set_rethrows(get_stack_optional<std::variant<Rethrows, double>>(j, "rethrows"));
+        x.set_top_level_return(get_stack_optional<std::variant<Return, double>>(j, "return"));
+        x.set_right(get_stack_optional<std::variant<Right, double>>(j, "right"));
+        x.set_sbyte(get_stack_optional<std::variant<Sbyte, double>>(j, "sbyte"));
+        x.set_sealed(get_stack_optional<std::variant<Sealed, double>>(j, "sealed"));
+        x.set_sel(get_stack_optional<std::variant<Sel, double>>(j, "SEL"));
+        x.set_select(get_stack_optional<std::variant<Select, double>>(j, "select"));
+        x.set_self(get_stack_optional<std::variant<Self, double>>(j, "Self"));
+        x.set_top_level_self(get_stack_optional<std::variant<SelfClass, double>>(j, "self"));
+        x.set_serialize(get_stack_optional<std::variant<Serialize, double>>(j, "serialize"));
+        x.set_set(get_stack_optional<std::variant<Set, double>>(j, "set"));
+        x.set_top_level_short(get_stack_optional<std::variant<Short, double>>(j, "short"));
+        x.set_top_level_signed(get_stack_optional<std::variant<Signed, double>>(j, "signed"));
+        x.set_top_level_sizeof(get_stack_optional<std::variant<Sizeof, double>>(j, "sizeof"));
+        x.set_stackalloc(get_stack_optional<std::variant<Stackalloc, double>>(j, "stackalloc"));
+        x.set_top_level_static(get_stack_optional<std::variant<Static, double>>(j, "static"));
+        x.set_top_level_static_assert(get_stack_optional<std::variant<StaticAssert, double>>(j, "static_assert"));
+        x.set_top_level_static_cast(get_stack_optional<std::variant<StaticCast, double>>(j, "static_cast"));
+        x.set_strictfp(get_stack_optional<std::variant<Strictfp, double>>(j, "strictfp"));
+        x.set_string(get_stack_optional<std::variant<String, double>>(j, "string"));
+        x.set_top_level_struct(get_stack_optional<std::variant<Struct, double>>(j, "struct"));
+        x.set_subscript(get_stack_optional<std::variant<Subscript, double>>(j, "subscript"));
+        x.set_super(get_stack_optional<std::variant<Super, double>>(j, "super"));
+        x.set_top_level_switch(get_stack_optional<std::variant<Switch, double>>(j, "switch"));
+        x.set_symbol(get_stack_optional<std::variant<Symbol, double>>(j, "symbol"));
+        x.set_top_level_synchronized(get_stack_optional<std::variant<Synchronized, double>>(j, "synchronized"));
+        x.set_system(get_stack_optional<std::variant<System, double>>(j, "system"));
+        x.set_top_level_template(get_stack_optional<std::variant<Template, double>>(j, "template"));
+        x.set_then(get_stack_optional<std::variant<Then, double>>(j, "then"));
+        x.set_top_level_this(get_stack_optional<std::variant<This, double>>(j, "this"));
+        x.set_top_level_thread_local(get_stack_optional<std::variant<ThreadLocal, double>>(j, "thread_local"));
+        x.set_top_level_throw(get_stack_optional<std::variant<Throw, double>>(j, "throw"));
+        x.set_throws(get_stack_optional<std::variant<Throws, double>>(j, "throws"));
+        x.set_to_json(get_stack_optional<std::variant<ToJson, double>>(j, "to_json"));
+        x.set_top_level(get_stack_optional<std::variant<TopLevelClass, double>>(j, "top_level"));
+        x.set_transient(get_stack_optional<std::variant<Transient, double>>(j, "transient"));
+        x.set_top_level_true(get_stack_optional<std::variant<True, double>>(j, "True"));
+        x.set_purple_true(get_stack_optional<std::variant<TrueClass, double>>(j, "true"));
+        x.set_top_level_try(get_stack_optional<std::variant<Try, double>>(j, "try"));
+        x.set_type(get_stack_optional<std::variant<Type, double>>(j, "Type"));
+        x.set_top_level_type(get_stack_optional<std::variant<TypeClass, double>>(j, "type"));
+        x.set_typealias(get_stack_optional<std::variant<Typealias, double>>(j, "typealias"));
+        x.set_top_level_typedef(get_stack_optional<std::variant<Typedef, double>>(j, "typedef"));
+        x.set_top_level_typeid(get_stack_optional<std::variant<Typeid, double>>(j, "typeid"));
+        x.set_top_level_typename(get_stack_optional<std::variant<Typename, double>>(j, "typename"));
+        x.set_typeof(get_stack_optional<std::variant<Typeof, double>>(j, "typeof"));
+        x.set_uint(get_stack_optional<std::variant<Uint, double>>(j, "uint"));
+        x.set_ulong(get_stack_optional<std::variant<Ulong, double>>(j, "ulong"));
+        x.set_unchecked(get_stack_optional<std::variant<Unchecked, double>>(j, "unchecked"));
+        x.set_undefined(get_stack_optional<std::variant<Undefined, double>>(j, "undefined"));
+        x.set_top_level_union(get_stack_optional<std::variant<Union, double>>(j, "union"));
+        x.set_unowned(get_stack_optional<std::variant<Unowned, double>>(j, "unowned"));
+        x.set_unsafe(get_stack_optional<std::variant<Unsafe, double>>(j, "unsafe"));
+        x.set_top_level_unsigned(get_stack_optional<std::variant<Unsigned, double>>(j, "unsigned"));
+        x.set_ushort(get_stack_optional<std::variant<Ushort, double>>(j, "ushort"));
+        x.set_top_level_using(get_stack_optional<std::variant<Using, double>>(j, "using"));
+        x.set_var(get_stack_optional<std::variant<Var, double>>(j, "var"));
+        x.set_top_level_virtual(get_stack_optional<std::variant<Virtual, double>>(j, "virtual"));
+        x.set_top_level_void(get_stack_optional<std::variant<Void, double>>(j, "void"));
+        x.set_top_level_volatile(get_stack_optional<std::variant<Volatile, double>>(j, "volatile"));
+        x.set_top_level_wchar_t(get_stack_optional<std::variant<WcharT, double>>(j, "wchar_t"));
+        x.set_weak(get_stack_optional<std::variant<Weak, double>>(j, "weak"));
+        x.set_where(get_stack_optional<std::variant<Where, double>>(j, "where"));
+        x.set_top_level_while(get_stack_optional<std::variant<While, double>>(j, "while"));
+        x.set_will_set(get_stack_optional<std::variant<WillSet, double>>(j, "willSet"));
+        x.set_with(get_stack_optional<std::variant<With, double>>(j, "with"));
+        x.set_top_level_xor(get_stack_optional<std::variant<Xor, double>>(j, "xor"));
+        x.set_top_level_xor_eq(get_stack_optional<std::variant<XorEq, double>>(j, "xor_eq"));
+        x.set_yes(get_stack_optional<std::variant<Yes, double>>(j, "YES"));
+        x.set_yield(get_stack_optional<std::variant<Yield, double>>(j, "yield"));
+    }
+
+    inline void to_json(json & j, const TopLevel & x) {
+        j = json::object();
+        j["_"] = x.get_empty();
+        j["_Bool"] = x.get_purple_bool();
+        j["_Complex"] = x.get_complex();
+        j["_Imaginery"] = x.get_imaginery();
+        j["abstract"] = x.get_abstract();
+        j["alignas"] = x.get_top_level_alignas();
+        j["alignof"] = x.get_top_level_alignof();
+        j["and"] = x.get_top_level_and();
+        j["and_eq"] = x.get_top_level_and_eq();
+        j["any"] = x.get_top_level_any();
+        j["Any"] = x.get_any();
+        j["array"] = x.get_array();
+        j["as"] = x.get_as();
+        j["asm"] = x.get_top_level_asm();
+        j["assert"] = x.get_assert();
+        j["associatedtype"] = x.get_associatedtype();
+        j["associativity"] = x.get_associativity();
+        j["async"] = x.get_async();
+        j["atomic"] = x.get_atomic();
+        j["atomic_cancel"] = x.get_top_level_atomic_cancel();
+        j["atomic_commit"] = x.get_top_level_atomic_commit();
+        j["atomic_noexcept"] = x.get_top_level_atomic_noexcept();
+        j["auto"] = x.get_top_level_auto();
+        j["await"] = x.get_await();
+        j["base"] = x.get_base();
+        j["bitand"] = x.get_top_level_bitand();
+        j["bitor"] = x.get_top_level_bitor();
+        j["BOOL"] = x.get_top_level_bool();
+        j["bool"] = x.get_fluffy_bool();
+        j["boolean"] = x.get_boolean();
+        j["break"] = x.get_top_level_break();
+        j["bycopy"] = x.get_bycopy();
+        j["byref"] = x.get_byref();
+        j["byte"] = x.get_byte();
+        j["case"] = x.get_top_level_case();
+        j["catch"] = x.get_top_level_catch();
+        j["chan"] = x.get_chan();
+        j["char"] = x.get_top_level_char();
+        j["char16_t"] = x.get_top_level_char16_t();
+        j["char32_t"] = x.get_top_level_char32_t();
+        j["checked"] = x.get_checked();
+        j["class"] = x.get_purple_class();
+        j["Class"] = x.get_top_level_class();
+        j["co_await"] = x.get_top_level_co_await();
+        j["co_return"] = x.get_top_level_co_return();
+        j["co_yield"] = x.get_top_level_co_yield();
+        j["compl"] = x.get_top_level_compl();
+        j["concept"] = x.get_top_level_concept();
+        j["console"] = x.get_console();
+        j["const"] = x.get_top_level_const();
+        j["const_cast"] = x.get_top_level_const_cast();
+        j["constexpr"] = x.get_top_level_constexpr();
+        j["constructor"] = x.get_constructor();
+        j["continue"] = x.get_top_level_continue();
+        j["convenience"] = x.get_convenience();
+        j["convert"] = x.get_convert();
+        j["converter"] = x.get_converter();
+        j["date"] = x.get_date();
+        j["date_parse_handling"] = x.get_date_parse_handling();
+        j["debugger"] = x.get_debugger();
+        j["decimal"] = x.get_decimal();
+        j["declare"] = x.get_declare();
+        j["decltype"] = x.get_top_level_decltype();
+        j["decode_string"] = x.get_decode_string();
+        j["def"] = x.get_def();
+        j["default"] = x.get_top_level_default();
+        j["defer"] = x.get_defer();
+        j["deinit"] = x.get_deinit();
+        j["del"] = x.get_del();
+        j["delegate"] = x.get_delegate();
+        j["delete"] = x.get_top_level_delete();
+        j["dict"] = x.get_dict();
+        j["dictionary"] = x.get_dictionary();
+        j["didSet"] = x.get_did_set();
+        j["do"] = x.get_top_level_do();
+        j["double"] = x.get_top_level_double();
+        j["dummy"] = x.get_dummy();
+        j["dynamic"] = x.get_dynamic();
+        j["dynamic_cast"] = x.get_top_level_dynamic_cast();
+        j["elif"] = x.get_elif();
+        j["else"] = x.get_top_level_else();
+        j["encode_quick_type"] = x.get_encode_quick_type();
+        j["enum"] = x.get_top_level_enum();
+        j["event"] = x.get_event();
+        j["except"] = x.get_except();
+        j["exception"] = x.get_exception();
+        j["explicit"] = x.get_top_level_explicit();
+        j["export"] = x.get_top_level_export();
+        j["exposing"] = x.get_exposing();
+        j["extends"] = x.get_extends();
+        j["extension"] = x.get_extension();
+        j["extern"] = x.get_top_level_extern();
+        j["fallthrough"] = x.get_fallthrough();
+        j["false"] = x.get_purple_false();
+        j["False"] = x.get_top_level_false();
+        j["fileprivate"] = x.get_fileprivate();
+        j["final"] = x.get_top_level_final();
+        j["finally"] = x.get_finally();
+        j["fixed"] = x.get_fixed();
+        j["float"] = x.get_top_level_float();
+        j["for"] = x.get_top_level_for();
+        j["foreach"] = x.get_foreach();
+        j["friend"] = x.get_top_level_friend();
+        j["from"] = x.get_from();
+        j["from_json"] = x.get_from_json();
+        j["func"] = x.get_func();
+        j["function"] = x.get_function();
+        j["get"] = x.get_get();
+        j["global"] = x.get_global();
+        j["go"] = x.get_go();
+        j["goto"] = x.get_top_level_goto();
+        j["guard"] = x.get_guard();
+        j["hasOwnProperty"] = x.get_has_own_property();
+        j["id"] = x.get_id();
+        j["if"] = x.get_top_level_if();
+        j["IMP"] = x.get_imp();
+        j["implements"] = x.get_implements();
+        j["implicit"] = x.get_implicit();
+        j["import"] = x.get_top_level_import();
+        j["in"] = x.get_in();
+        j["indirect"] = x.get_indirect();
+        j["infix"] = x.get_infix();
+        j["init"] = x.get_init();
+        j["inline"] = x.get_top_level_inline();
+        j["inout"] = x.get_inout();
+        j["instanceof"] = x.get_instanceof();
+        j["int"] = x.get_top_level_int();
+        j["interface"] = x.get_interface();
+        j["internal"] = x.get_internal();
+        j["is"] = x.get_is();
+        j["iterable"] = x.get_iterable();
+        j["jdec"] = x.get_jdec();
+        j["jenc"] = x.get_jenc();
+        j["jpipe"] = x.get_jpipe();
+        j["json"] = x.get_json();
+        j["json_converter"] = x.get_json_converter();
+        j["json_serializer"] = x.get_json_serializer();
+        j["json_token"] = x.get_json_token();
+        j["json_writer"] = x.get_json_writer();
+        j["lambda"] = x.get_lambda();
+        j["lazy"] = x.get_lazy();
+        j["left"] = x.get_left();
+        j["let"] = x.get_let();
+        j["list"] = x.get_list();
+        j["lock"] = x.get_lock();
+        j["long"] = x.get_top_level_long();
+        j["map"] = x.get_map();
+        j["metadata_property_handling"] = x.get_metadata_property_handling();
+        j["module"] = x.get_top_level_module();
+        j["mutable"] = x.get_top_level_mutable();
+        j["mutating"] = x.get_mutating();
+        j["namespace"] = x.get_top_level_namespace();
+        j["native"] = x.get_native();
+        j["new"] = x.get_top_level_new();
+        j["newtonsoft"] = x.get_newtonsoft();
+        j["nil"] = x.get_nil();
+        j["NO"] = x.get_no();
+        j["noexcept"] = x.get_top_level_noexcept();
+        j["nonatomic"] = x.get_nonatomic();
+        j["none"] = x.get_top_level_none();
+        j["None"] = x.get_none();
+        j["nonlocal"] = x.get_nonlocal();
+        j["nonmutating"] = x.get_nonmutating();
+        j["not"] = x.get_top_level_not();
+        j["not_eq"] = x.get_top_level_not_eq();
+        j["NSString"] = x.get_ns_string();
+        j["NULL"] = x.get_null();
+        j["null"] = x.get_top_level_null();
+        j["nullptr"] = x.get_top_level_nullptr();
+        j["number"] = x.get_number();
+        j["object"] = x.get_object();
+        j["of"] = x.get_of();
+        j["oneway"] = x.get_oneway();
+        j["open"] = x.get_open();
+        j["operator"] = x.get_top_level_operator();
+        j["optional"] = x.get_optional();
+        j["or"] = x.get_top_level_or();
+        j["or_eq"] = x.get_top_level_or_eq();
+        j["out"] = x.get_out();
+        j["override"] = x.get_top_level_override();
+        j["package"] = x.get_package();
+        j["params"] = x.get_params();
+        j["pass"] = x.get_pass();
+        j["port"] = x.get_port();
+        j["postfix"] = x.get_postfix();
+        j["precedence"] = x.get_precedence();
+        j["prefix"] = x.get_prefix();
+        j["print"] = x.get_print();
+        j["printf"] = x.get_printf();
+        j["private"] = x.get_top_level_private();
+        j["protected"] = x.get_top_level_protected();
+        j["Protocol"] = x.get_protocol();
+        j["protocol"] = x.get_top_level_protocol();
+        j["public"] = x.get_top_level_public();
+        j["quicktype"] = x.get_quicktype();
+        j["raise"] = x.get_raise();
+        j["range"] = x.get_range();
+        j["readonly"] = x.get_readonly();
+        j["ref"] = x.get_ref();
+        j["register"] = x.get_top_level_register();
+        j["reinterpret_cast"] = x.get_top_level_reinterpret_cast();
+        j["repeat"] = x.get_repeat();
+        j["require"] = x.get_require();
+        j["required"] = x.get_required();
+        j["requires"] = x.get_top_level_requires();
+        j["restrict"] = x.get_restrict();
+        j["retain"] = x.get_retain();
+        j["rethrows"] = x.get_rethrows();
+        j["return"] = x.get_top_level_return();
+        j["right"] = x.get_right();
+        j["sbyte"] = x.get_sbyte();
+        j["sealed"] = x.get_sealed();
+        j["SEL"] = x.get_sel();
+        j["select"] = x.get_select();
+        j["Self"] = x.get_self();
+        j["self"] = x.get_top_level_self();
+        j["serialize"] = x.get_serialize();
+        j["set"] = x.get_set();
+        j["short"] = x.get_top_level_short();
+        j["signed"] = x.get_top_level_signed();
+        j["sizeof"] = x.get_top_level_sizeof();
+        j["stackalloc"] = x.get_stackalloc();
+        j["static"] = x.get_top_level_static();
+        j["static_assert"] = x.get_top_level_static_assert();
+        j["static_cast"] = x.get_top_level_static_cast();
+        j["strictfp"] = x.get_strictfp();
+        j["string"] = x.get_string();
+        j["struct"] = x.get_top_level_struct();
+        j["subscript"] = x.get_subscript();
+        j["super"] = x.get_super();
+        j["switch"] = x.get_top_level_switch();
+        j["symbol"] = x.get_symbol();
+        j["synchronized"] = x.get_top_level_synchronized();
+        j["system"] = x.get_system();
+        j["template"] = x.get_top_level_template();
+        j["then"] = x.get_then();
+        j["this"] = x.get_top_level_this();
+        j["thread_local"] = x.get_top_level_thread_local();
+        j["throw"] = x.get_top_level_throw();
+        j["throws"] = x.get_throws();
+        j["to_json"] = x.get_to_json();
+        j["top_level"] = x.get_top_level();
+        j["transient"] = x.get_transient();
+        j["True"] = x.get_top_level_true();
+        j["true"] = x.get_purple_true();
+        j["try"] = x.get_top_level_try();
+        j["Type"] = x.get_type();
+        j["type"] = x.get_top_level_type();
+        j["typealias"] = x.get_typealias();
+        j["typedef"] = x.get_top_level_typedef();
+        j["typeid"] = x.get_top_level_typeid();
+        j["typename"] = x.get_top_level_typename();
+        j["typeof"] = x.get_typeof();
+        j["uint"] = x.get_uint();
+        j["ulong"] = x.get_ulong();
+        j["unchecked"] = x.get_unchecked();
+        j["undefined"] = x.get_undefined();
+        j["union"] = x.get_top_level_union();
+        j["unowned"] = x.get_unowned();
+        j["unsafe"] = x.get_unsafe();
+        j["unsigned"] = x.get_top_level_unsigned();
+        j["ushort"] = x.get_ushort();
+        j["using"] = x.get_top_level_using();
+        j["var"] = x.get_var();
+        j["virtual"] = x.get_top_level_virtual();
+        j["void"] = x.get_top_level_void();
+        j["volatile"] = x.get_top_level_volatile();
+        j["wchar_t"] = x.get_top_level_wchar_t();
+        j["weak"] = x.get_weak();
+        j["where"] = x.get_where();
+        j["while"] = x.get_top_level_while();
+        j["willSet"] = x.get_will_set();
+        j["with"] = x.get_with();
+        j["xor"] = x.get_top_level_xor();
+        j["xor_eq"] = x.get_top_level_xor_eq();
+        j["YES"] = x.get_yes();
+        j["yield"] = x.get_yield();
+    }
+}
+namespace nlohmann {
+    inline void adl_serializer<std::variant<quicktype::Abstract, double>>::from_json(const json & j, std::variant<quicktype::Abstract, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Abstract>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Abstract, double>>::to_json(json & j, const std::variant<quicktype::Abstract, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Abstract>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Any, double>>::from_json(const json & j, std::variant<quicktype::Any, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Any>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Any, double>>::to_json(json & j, const std::variant<quicktype::Any, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Any>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Array, double>>::from_json(const json & j, std::variant<quicktype::Array, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Array>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Array, double>>::to_json(json & j, const std::variant<quicktype::Array, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Array>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::As, double>>::from_json(const json & j, std::variant<quicktype::As, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::As>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::As, double>>::to_json(json & j, const std::variant<quicktype::As, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::As>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Assert, double>>::from_json(const json & j, std::variant<quicktype::Assert, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Assert>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Assert, double>>::to_json(json & j, const std::variant<quicktype::Assert, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Assert>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Associatedtype, double>>::from_json(const json & j, std::variant<quicktype::Associatedtype, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Associatedtype>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Associatedtype, double>>::to_json(json & j, const std::variant<quicktype::Associatedtype, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Associatedtype>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Associativity, double>>::from_json(const json & j, std::variant<quicktype::Associativity, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Associativity>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Associativity, double>>::to_json(json & j, const std::variant<quicktype::Associativity, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Associativity>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Async, double>>::from_json(const json & j, std::variant<quicktype::Async, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Async>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Async, double>>::to_json(json & j, const std::variant<quicktype::Async, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Async>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Atomic, double>>::from_json(const json & j, std::variant<quicktype::Atomic, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Atomic>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Atomic, double>>::to_json(json & j, const std::variant<quicktype::Atomic, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Atomic>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Await, double>>::from_json(const json & j, std::variant<quicktype::Await, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Await>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Await, double>>::to_json(json & j, const std::variant<quicktype::Await, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Await>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Base, double>>::from_json(const json & j, std::variant<quicktype::Base, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Base>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Base, double>>::to_json(json & j, const std::variant<quicktype::Base, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Base>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Boolean, double>>::from_json(const json & j, std::variant<quicktype::Boolean, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Boolean>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Boolean, double>>::to_json(json & j, const std::variant<quicktype::Boolean, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Boolean>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bycopy, double>>::from_json(const json & j, std::variant<quicktype::Bycopy, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Bycopy>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bycopy, double>>::to_json(json & j, const std::variant<quicktype::Bycopy, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Bycopy>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Byref, double>>::from_json(const json & j, std::variant<quicktype::Byref, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Byref>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Byref, double>>::to_json(json & j, const std::variant<quicktype::Byref, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Byref>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Byte, double>>::from_json(const json & j, std::variant<quicktype::Byte, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Byte>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Byte, double>>::to_json(json & j, const std::variant<quicktype::Byte, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Byte>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Chan, double>>::from_json(const json & j, std::variant<quicktype::Chan, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Chan>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Chan, double>>::to_json(json & j, const std::variant<quicktype::Chan, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Chan>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Checked, double>>::from_json(const json & j, std::variant<quicktype::Checked, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Checked>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Checked, double>>::to_json(json & j, const std::variant<quicktype::Checked, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Checked>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Complex, double>>::from_json(const json & j, std::variant<quicktype::Complex, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Complex>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Complex, double>>::to_json(json & j, const std::variant<quicktype::Complex, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Complex>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Console, double>>::from_json(const json & j, std::variant<quicktype::Console, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Console>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Console, double>>::to_json(json & j, const std::variant<quicktype::Console, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Console>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Constructor, double>>::from_json(const json & j, std::variant<quicktype::Constructor, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Constructor>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Constructor, double>>::to_json(json & j, const std::variant<quicktype::Constructor, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Constructor>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Convenience, double>>::from_json(const json & j, std::variant<quicktype::Convenience, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Convenience>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Convenience, double>>::to_json(json & j, const std::variant<quicktype::Convenience, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Convenience>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Convert, double>>::from_json(const json & j, std::variant<quicktype::Convert, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Convert>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Convert, double>>::to_json(json & j, const std::variant<quicktype::Convert, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Convert>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Converter, double>>::from_json(const json & j, std::variant<quicktype::Converter, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Converter>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Converter, double>>::to_json(json & j, const std::variant<quicktype::Converter, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Converter>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Date, double>>::from_json(const json & j, std::variant<quicktype::Date, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Date>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Date, double>>::to_json(json & j, const std::variant<quicktype::Date, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Date>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DateParseHandling, double>>::from_json(const json & j, std::variant<quicktype::DateParseHandling, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::DateParseHandling>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DateParseHandling, double>>::to_json(json & j, const std::variant<quicktype::DateParseHandling, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::DateParseHandling>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Debugger, double>>::from_json(const json & j, std::variant<quicktype::Debugger, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Debugger>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Debugger, double>>::to_json(json & j, const std::variant<quicktype::Debugger, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Debugger>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Decimal, double>>::from_json(const json & j, std::variant<quicktype::Decimal, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Decimal>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Decimal, double>>::to_json(json & j, const std::variant<quicktype::Decimal, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Decimal>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Declare, double>>::from_json(const json & j, std::variant<quicktype::Declare, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Declare>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Declare, double>>::to_json(json & j, const std::variant<quicktype::Declare, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Declare>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DecodeString, double>>::from_json(const json & j, std::variant<quicktype::DecodeString, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::DecodeString>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DecodeString, double>>::to_json(json & j, const std::variant<quicktype::DecodeString, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::DecodeString>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Def, double>>::from_json(const json & j, std::variant<quicktype::Def, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Def>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Def, double>>::to_json(json & j, const std::variant<quicktype::Def, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Def>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Defer, double>>::from_json(const json & j, std::variant<quicktype::Defer, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Defer>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Defer, double>>::to_json(json & j, const std::variant<quicktype::Defer, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Defer>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Deinit, double>>::from_json(const json & j, std::variant<quicktype::Deinit, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Deinit>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Deinit, double>>::to_json(json & j, const std::variant<quicktype::Deinit, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Deinit>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Del, double>>::from_json(const json & j, std::variant<quicktype::Del, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Del>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Del, double>>::to_json(json & j, const std::variant<quicktype::Del, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Del>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Delegate, double>>::from_json(const json & j, std::variant<quicktype::Delegate, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Delegate>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Delegate, double>>::to_json(json & j, const std::variant<quicktype::Delegate, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Delegate>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Dict, double>>::from_json(const json & j, std::variant<quicktype::Dict, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Dict>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Dict, double>>::to_json(json & j, const std::variant<quicktype::Dict, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Dict>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Dictionary, double>>::from_json(const json & j, std::variant<quicktype::Dictionary, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Dictionary>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Dictionary, double>>::to_json(json & j, const std::variant<quicktype::Dictionary, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Dictionary>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DidSet, double>>::from_json(const json & j, std::variant<quicktype::DidSet, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::DidSet>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DidSet, double>>::to_json(json & j, const std::variant<quicktype::DidSet, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::DidSet>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Dynamic, double>>::from_json(const json & j, std::variant<quicktype::Dynamic, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Dynamic>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Dynamic, double>>::to_json(json & j, const std::variant<quicktype::Dynamic, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Dynamic>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Elif, double>>::from_json(const json & j, std::variant<quicktype::Elif, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Elif>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Elif, double>>::to_json(json & j, const std::variant<quicktype::Elif, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Elif>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Empty, double>>::from_json(const json & j, std::variant<quicktype::Empty, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Empty>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Empty, double>>::to_json(json & j, const std::variant<quicktype::Empty, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Empty>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::EncodeQuickType, double>>::from_json(const json & j, std::variant<quicktype::EncodeQuickType, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::EncodeQuickType>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::EncodeQuickType, double>>::to_json(json & j, const std::variant<quicktype::EncodeQuickType, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::EncodeQuickType>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Event, double>>::from_json(const json & j, std::variant<quicktype::Event, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Event>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Event, double>>::to_json(json & j, const std::variant<quicktype::Event, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Event>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Except, double>>::from_json(const json & j, std::variant<quicktype::Except, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Except>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Except, double>>::to_json(json & j, const std::variant<quicktype::Except, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Except>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Exception, double>>::from_json(const json & j, std::variant<quicktype::Exception, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Exception>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Exception, double>>::to_json(json & j, const std::variant<quicktype::Exception, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Exception>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Exposing, double>>::from_json(const json & j, std::variant<quicktype::Exposing, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Exposing>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Exposing, double>>::to_json(json & j, const std::variant<quicktype::Exposing, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Exposing>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Extends, double>>::from_json(const json & j, std::variant<quicktype::Extends, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Extends>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Extends, double>>::to_json(json & j, const std::variant<quicktype::Extends, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Extends>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Extension, double>>::from_json(const json & j, std::variant<quicktype::Extension, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Extension>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Extension, double>>::to_json(json & j, const std::variant<quicktype::Extension, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Extension>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Fallthrough, double>>::from_json(const json & j, std::variant<quicktype::Fallthrough, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Fallthrough>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Fallthrough, double>>::to_json(json & j, const std::variant<quicktype::Fallthrough, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Fallthrough>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Fileprivate, double>>::from_json(const json & j, std::variant<quicktype::Fileprivate, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Fileprivate>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Fileprivate, double>>::to_json(json & j, const std::variant<quicktype::Fileprivate, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Fileprivate>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Finally, double>>::from_json(const json & j, std::variant<quicktype::Finally, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Finally>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Finally, double>>::to_json(json & j, const std::variant<quicktype::Finally, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Finally>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Fixed, double>>::from_json(const json & j, std::variant<quicktype::Fixed, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Fixed>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Fixed, double>>::to_json(json & j, const std::variant<quicktype::Fixed, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Fixed>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::UnionBoolBool, double>>::from_json(const json & j, std::variant<quicktype::UnionBoolBool, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::UnionBoolBool>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::UnionBoolBool, double>>::to_json(json & j, const std::variant<quicktype::UnionBoolBool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::UnionBoolBool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Foreach, double>>::from_json(const json & j, std::variant<quicktype::Foreach, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Foreach>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Foreach, double>>::to_json(json & j, const std::variant<quicktype::Foreach, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Foreach>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::From, double>>::from_json(const json & j, std::variant<quicktype::From, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::From>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::From, double>>::to_json(json & j, const std::variant<quicktype::From, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::From>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FromJson, double>>::from_json(const json & j, std::variant<quicktype::FromJson, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FromJson>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FromJson, double>>::to_json(json & j, const std::variant<quicktype::FromJson, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FromJson>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Func, double>>::from_json(const json & j, std::variant<quicktype::Func, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Func>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Func, double>>::to_json(json & j, const std::variant<quicktype::Func, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Func>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Function, double>>::from_json(const json & j, std::variant<quicktype::Function, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Function>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Function, double>>::to_json(json & j, const std::variant<quicktype::Function, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Function>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Get, double>>::from_json(const json & j, std::variant<quicktype::Get, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Get>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Get, double>>::to_json(json & j, const std::variant<quicktype::Get, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Get>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Global, double>>::from_json(const json & j, std::variant<quicktype::Global, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Global>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Global, double>>::to_json(json & j, const std::variant<quicktype::Global, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Global>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Go, double>>::from_json(const json & j, std::variant<quicktype::Go, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Go>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Go, double>>::to_json(json & j, const std::variant<quicktype::Go, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Go>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Guard, double>>::from_json(const json & j, std::variant<quicktype::Guard, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Guard>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Guard, double>>::to_json(json & j, const std::variant<quicktype::Guard, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Guard>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::HasOwnProperty, double>>::from_json(const json & j, std::variant<quicktype::HasOwnProperty, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::HasOwnProperty>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::HasOwnProperty, double>>::to_json(json & j, const std::variant<quicktype::HasOwnProperty, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::HasOwnProperty>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Id, double>>::from_json(const json & j, std::variant<quicktype::Id, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Id>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Id, double>>::to_json(json & j, const std::variant<quicktype::Id, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Id>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Imaginery, double>>::from_json(const json & j, std::variant<quicktype::Imaginery, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Imaginery>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Imaginery, double>>::to_json(json & j, const std::variant<quicktype::Imaginery, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Imaginery>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Imp, double>>::from_json(const json & j, std::variant<quicktype::Imp, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Imp>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Imp, double>>::to_json(json & j, const std::variant<quicktype::Imp, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Imp>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Implements, double>>::from_json(const json & j, std::variant<quicktype::Implements, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Implements>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Implements, double>>::to_json(json & j, const std::variant<quicktype::Implements, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Implements>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Implicit, double>>::from_json(const json & j, std::variant<quicktype::Implicit, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Implicit>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Implicit, double>>::to_json(json & j, const std::variant<quicktype::Implicit, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Implicit>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::In, double>>::from_json(const json & j, std::variant<quicktype::In, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::In>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::In, double>>::to_json(json & j, const std::variant<quicktype::In, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::In>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Indirect, double>>::from_json(const json & j, std::variant<quicktype::Indirect, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Indirect>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Indirect, double>>::to_json(json & j, const std::variant<quicktype::Indirect, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Indirect>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Infix, double>>::from_json(const json & j, std::variant<quicktype::Infix, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Infix>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Infix, double>>::to_json(json & j, const std::variant<quicktype::Infix, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Infix>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Init, double>>::from_json(const json & j, std::variant<quicktype::Init, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Init>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Init, double>>::to_json(json & j, const std::variant<quicktype::Init, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Init>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Inout, double>>::from_json(const json & j, std::variant<quicktype::Inout, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Inout>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Inout, double>>::to_json(json & j, const std::variant<quicktype::Inout, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Inout>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Instanceof, double>>::from_json(const json & j, std::variant<quicktype::Instanceof, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Instanceof>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Instanceof, double>>::to_json(json & j, const std::variant<quicktype::Instanceof, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Instanceof>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Interface, double>>::from_json(const json & j, std::variant<quicktype::Interface, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Interface>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Interface, double>>::to_json(json & j, const std::variant<quicktype::Interface, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Interface>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Internal, double>>::from_json(const json & j, std::variant<quicktype::Internal, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Internal>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Internal, double>>::to_json(json & j, const std::variant<quicktype::Internal, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Internal>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Is, double>>::from_json(const json & j, std::variant<quicktype::Is, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Is>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Is, double>>::to_json(json & j, const std::variant<quicktype::Is, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Is>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Iterable, double>>::from_json(const json & j, std::variant<quicktype::Iterable, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Iterable>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Iterable, double>>::to_json(json & j, const std::variant<quicktype::Iterable, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Iterable>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Jdec, double>>::from_json(const json & j, std::variant<quicktype::Jdec, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Jdec>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Jdec, double>>::to_json(json & j, const std::variant<quicktype::Jdec, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Jdec>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Jenc, double>>::from_json(const json & j, std::variant<quicktype::Jenc, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Jenc>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Jenc, double>>::to_json(json & j, const std::variant<quicktype::Jenc, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Jenc>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Jpipe, double>>::from_json(const json & j, std::variant<quicktype::Jpipe, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Jpipe>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Jpipe, double>>::to_json(json & j, const std::variant<quicktype::Jpipe, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Jpipe>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Json, double>>::from_json(const json & j, std::variant<quicktype::Json, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Json>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Json, double>>::to_json(json & j, const std::variant<quicktype::Json, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Json>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonConverter, double>>::from_json(const json & j, std::variant<quicktype::JsonConverter, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::JsonConverter>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonConverter, double>>::to_json(json & j, const std::variant<quicktype::JsonConverter, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::JsonConverter>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonSerializer, double>>::from_json(const json & j, std::variant<quicktype::JsonSerializer, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::JsonSerializer>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonSerializer, double>>::to_json(json & j, const std::variant<quicktype::JsonSerializer, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::JsonSerializer>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonToken, double>>::from_json(const json & j, std::variant<quicktype::JsonToken, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::JsonToken>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonToken, double>>::to_json(json & j, const std::variant<quicktype::JsonToken, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::JsonToken>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonWriter, double>>::from_json(const json & j, std::variant<quicktype::JsonWriter, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::JsonWriter>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::JsonWriter, double>>::to_json(json & j, const std::variant<quicktype::JsonWriter, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::JsonWriter>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Lambda, double>>::from_json(const json & j, std::variant<quicktype::Lambda, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Lambda>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Lambda, double>>::to_json(json & j, const std::variant<quicktype::Lambda, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Lambda>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Lazy, double>>::from_json(const json & j, std::variant<quicktype::Lazy, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Lazy>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Lazy, double>>::to_json(json & j, const std::variant<quicktype::Lazy, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Lazy>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Left, double>>::from_json(const json & j, std::variant<quicktype::Left, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Left>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Left, double>>::to_json(json & j, const std::variant<quicktype::Left, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Left>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Let, double>>::from_json(const json & j, std::variant<quicktype::Let, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Let>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Let, double>>::to_json(json & j, const std::variant<quicktype::Let, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Let>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::List, double>>::from_json(const json & j, std::variant<quicktype::List, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::List>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::List, double>>::to_json(json & j, const std::variant<quicktype::List, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::List>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Lock, double>>::from_json(const json & j, std::variant<quicktype::Lock, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Lock>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Lock, double>>::to_json(json & j, const std::variant<quicktype::Lock, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Lock>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Map, double>>::from_json(const json & j, std::variant<quicktype::Map, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Map>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Map, double>>::to_json(json & j, const std::variant<quicktype::Map, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Map>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MetadataPropertyHandling, double>>::from_json(const json & j, std::variant<quicktype::MetadataPropertyHandling, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::MetadataPropertyHandling>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::MetadataPropertyHandling, double>>::to_json(json & j, const std::variant<quicktype::MetadataPropertyHandling, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::MetadataPropertyHandling>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Mutating, double>>::from_json(const json & j, std::variant<quicktype::Mutating, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Mutating>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Mutating, double>>::to_json(json & j, const std::variant<quicktype::Mutating, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Mutating>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Native, double>>::from_json(const json & j, std::variant<quicktype::Native, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Native>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Native, double>>::to_json(json & j, const std::variant<quicktype::Native, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Native>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Newtonsoft, double>>::from_json(const json & j, std::variant<quicktype::Newtonsoft, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Newtonsoft>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Newtonsoft, double>>::to_json(json & j, const std::variant<quicktype::Newtonsoft, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Newtonsoft>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nil, double>>::from_json(const json & j, std::variant<quicktype::Nil, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Nil>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nil, double>>::to_json(json & j, const std::variant<quicktype::Nil, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Nil>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::No, double>>::from_json(const json & j, std::variant<quicktype::No, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::No>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::No, double>>::to_json(json & j, const std::variant<quicktype::No, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::No>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nonatomic, double>>::from_json(const json & j, std::variant<quicktype::Nonatomic, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Nonatomic>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nonatomic, double>>::to_json(json & j, const std::variant<quicktype::Nonatomic, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Nonatomic>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::None, double>>::from_json(const json & j, std::variant<quicktype::None, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::None>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::None, double>>::to_json(json & j, const std::variant<quicktype::None, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::None>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nonlocal, double>>::from_json(const json & j, std::variant<quicktype::Nonlocal, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Nonlocal>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nonlocal, double>>::to_json(json & j, const std::variant<quicktype::Nonlocal, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Nonlocal>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nonmutating, double>>::from_json(const json & j, std::variant<quicktype::Nonmutating, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Nonmutating>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nonmutating, double>>::to_json(json & j, const std::variant<quicktype::Nonmutating, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Nonmutating>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NsString, double>>::from_json(const json & j, std::variant<quicktype::NsString, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::NsString>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NsString, double>>::to_json(json & j, const std::variant<quicktype::NsString, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::NsString>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Null, double>>::from_json(const json & j, std::variant<quicktype::Null, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Null>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Null, double>>::to_json(json & j, const std::variant<quicktype::Null, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Null>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Number, double>>::from_json(const json & j, std::variant<quicktype::Number, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Number>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Number, double>>::to_json(json & j, const std::variant<quicktype::Number, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Number>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Object, double>>::from_json(const json & j, std::variant<quicktype::Object, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Object>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Object, double>>::to_json(json & j, const std::variant<quicktype::Object, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Object>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Of, double>>::from_json(const json & j, std::variant<quicktype::Of, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Of>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Of, double>>::to_json(json & j, const std::variant<quicktype::Of, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Of>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Oneway, double>>::from_json(const json & j, std::variant<quicktype::Oneway, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Oneway>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Oneway, double>>::to_json(json & j, const std::variant<quicktype::Oneway, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Oneway>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Open, double>>::from_json(const json & j, std::variant<quicktype::Open, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Open>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Open, double>>::to_json(json & j, const std::variant<quicktype::Open, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Open>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Optional, double>>::from_json(const json & j, std::variant<quicktype::Optional, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Optional>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Optional, double>>::to_json(json & j, const std::variant<quicktype::Optional, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Optional>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Out, double>>::from_json(const json & j, std::variant<quicktype::Out, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Out>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Out, double>>::to_json(json & j, const std::variant<quicktype::Out, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Out>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Package, double>>::from_json(const json & j, std::variant<quicktype::Package, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Package>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Package, double>>::to_json(json & j, const std::variant<quicktype::Package, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Package>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Params, double>>::from_json(const json & j, std::variant<quicktype::Params, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Params>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Params, double>>::to_json(json & j, const std::variant<quicktype::Params, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Params>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Pass, double>>::from_json(const json & j, std::variant<quicktype::Pass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Pass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Pass, double>>::to_json(json & j, const std::variant<quicktype::Pass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Pass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Port, double>>::from_json(const json & j, std::variant<quicktype::Port, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Port>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Port, double>>::to_json(json & j, const std::variant<quicktype::Port, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Port>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Postfix, double>>::from_json(const json & j, std::variant<quicktype::Postfix, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Postfix>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Postfix, double>>::to_json(json & j, const std::variant<quicktype::Postfix, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Postfix>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Precedence, double>>::from_json(const json & j, std::variant<quicktype::Precedence, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Precedence>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Precedence, double>>::to_json(json & j, const std::variant<quicktype::Precedence, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Precedence>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Prefix, double>>::from_json(const json & j, std::variant<quicktype::Prefix, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Prefix>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Prefix, double>>::to_json(json & j, const std::variant<quicktype::Prefix, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Prefix>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Print, double>>::from_json(const json & j, std::variant<quicktype::Print, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Print>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Print, double>>::to_json(json & j, const std::variant<quicktype::Print, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Print>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Printf, double>>::from_json(const json & j, std::variant<quicktype::Printf, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Printf>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Printf, double>>::to_json(json & j, const std::variant<quicktype::Printf, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Printf>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Protocol, double>>::from_json(const json & j, std::variant<quicktype::Protocol, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Protocol>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Protocol, double>>::to_json(json & j, const std::variant<quicktype::Protocol, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Protocol>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::BoolClass, double>>::from_json(const json & j, std::variant<quicktype::BoolClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::BoolClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::BoolClass, double>>::to_json(json & j, const std::variant<quicktype::BoolClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::BoolClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ClassClass, double>>::from_json(const json & j, std::variant<quicktype::ClassClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::ClassClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ClassClass, double>>::to_json(json & j, const std::variant<quicktype::ClassClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ClassClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FalseClass, double>>::from_json(const json & j, std::variant<quicktype::FalseClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::FalseClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::FalseClass, double>>::to_json(json & j, const std::variant<quicktype::FalseClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::FalseClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::TrueClass, double>>::from_json(const json & j, std::variant<quicktype::TrueClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::TrueClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::TrueClass, double>>::to_json(json & j, const std::variant<quicktype::TrueClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::TrueClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Quicktype, double>>::from_json(const json & j, std::variant<quicktype::Quicktype, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Quicktype>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Quicktype, double>>::to_json(json & j, const std::variant<quicktype::Quicktype, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Quicktype>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Raise, double>>::from_json(const json & j, std::variant<quicktype::Raise, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Raise>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Raise, double>>::to_json(json & j, const std::variant<quicktype::Raise, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Raise>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Range, double>>::from_json(const json & j, std::variant<quicktype::Range, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Range>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Range, double>>::to_json(json & j, const std::variant<quicktype::Range, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Range>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Readonly, double>>::from_json(const json & j, std::variant<quicktype::Readonly, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Readonly>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Readonly, double>>::to_json(json & j, const std::variant<quicktype::Readonly, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Readonly>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Ref, double>>::from_json(const json & j, std::variant<quicktype::Ref, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Ref>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Ref, double>>::to_json(json & j, const std::variant<quicktype::Ref, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Ref>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Repeat, double>>::from_json(const json & j, std::variant<quicktype::Repeat, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Repeat>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Repeat, double>>::to_json(json & j, const std::variant<quicktype::Repeat, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Repeat>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Require, double>>::from_json(const json & j, std::variant<quicktype::Require, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Require>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Require, double>>::to_json(json & j, const std::variant<quicktype::Require, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Require>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Required, double>>::from_json(const json & j, std::variant<quicktype::Required, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Required>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Required, double>>::to_json(json & j, const std::variant<quicktype::Required, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Required>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Restrict, double>>::from_json(const json & j, std::variant<quicktype::Restrict, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Restrict>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Restrict, double>>::to_json(json & j, const std::variant<quicktype::Restrict, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Restrict>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Retain, double>>::from_json(const json & j, std::variant<quicktype::Retain, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Retain>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Retain, double>>::to_json(json & j, const std::variant<quicktype::Retain, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Retain>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rethrows, double>>::from_json(const json & j, std::variant<quicktype::Rethrows, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Rethrows>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Rethrows, double>>::to_json(json & j, const std::variant<quicktype::Rethrows, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Rethrows>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Right, double>>::from_json(const json & j, std::variant<quicktype::Right, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Right>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Right, double>>::to_json(json & j, const std::variant<quicktype::Right, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Right>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sbyte, double>>::from_json(const json & j, std::variant<quicktype::Sbyte, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Sbyte>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sbyte, double>>::to_json(json & j, const std::variant<quicktype::Sbyte, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Sbyte>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sealed, double>>::from_json(const json & j, std::variant<quicktype::Sealed, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Sealed>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sealed, double>>::to_json(json & j, const std::variant<quicktype::Sealed, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Sealed>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sel, double>>::from_json(const json & j, std::variant<quicktype::Sel, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Sel>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sel, double>>::to_json(json & j, const std::variant<quicktype::Sel, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Sel>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Select, double>>::from_json(const json & j, std::variant<quicktype::Select, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Select>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Select, double>>::to_json(json & j, const std::variant<quicktype::Select, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Select>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Self, double>>::from_json(const json & j, std::variant<quicktype::Self, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Self>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Self, double>>::to_json(json & j, const std::variant<quicktype::Self, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Self>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Serialize, double>>::from_json(const json & j, std::variant<quicktype::Serialize, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Serialize>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Serialize, double>>::to_json(json & j, const std::variant<quicktype::Serialize, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Serialize>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Set, double>>::from_json(const json & j, std::variant<quicktype::Set, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Set>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Set, double>>::to_json(json & j, const std::variant<quicktype::Set, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Set>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Stackalloc, double>>::from_json(const json & j, std::variant<quicktype::Stackalloc, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Stackalloc>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Stackalloc, double>>::to_json(json & j, const std::variant<quicktype::Stackalloc, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Stackalloc>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Strictfp, double>>::from_json(const json & j, std::variant<quicktype::Strictfp, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Strictfp>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Strictfp, double>>::to_json(json & j, const std::variant<quicktype::Strictfp, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Strictfp>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::String, double>>::from_json(const json & j, std::variant<quicktype::String, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::String>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::String, double>>::to_json(json & j, const std::variant<quicktype::String, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::String>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Subscript, double>>::from_json(const json & j, std::variant<quicktype::Subscript, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Subscript>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Subscript, double>>::to_json(json & j, const std::variant<quicktype::Subscript, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Subscript>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Super, double>>::from_json(const json & j, std::variant<quicktype::Super, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Super>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Super, double>>::to_json(json & j, const std::variant<quicktype::Super, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Super>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Symbol, double>>::from_json(const json & j, std::variant<quicktype::Symbol, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Symbol>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Symbol, double>>::to_json(json & j, const std::variant<quicktype::Symbol, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Symbol>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::System, double>>::from_json(const json & j, std::variant<quicktype::System, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::System>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::System, double>>::to_json(json & j, const std::variant<quicktype::System, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::System>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Then, double>>::from_json(const json & j, std::variant<quicktype::Then, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Then>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Then, double>>::to_json(json & j, const std::variant<quicktype::Then, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Then>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Throws, double>>::from_json(const json & j, std::variant<quicktype::Throws, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Throws>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Throws, double>>::to_json(json & j, const std::variant<quicktype::Throws, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Throws>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ToJson, double>>::from_json(const json & j, std::variant<quicktype::ToJson, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::ToJson>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ToJson, double>>::to_json(json & j, const std::variant<quicktype::ToJson, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ToJson>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::TopLevelClass, double>>::from_json(const json & j, std::variant<quicktype::TopLevelClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::TopLevelClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::TopLevelClass, double>>::to_json(json & j, const std::variant<quicktype::TopLevelClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::TopLevelClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Alignas, double>>::from_json(const json & j, std::variant<quicktype::Alignas, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Alignas>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Alignas, double>>::to_json(json & j, const std::variant<quicktype::Alignas, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Alignas>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Alignof, double>>::from_json(const json & j, std::variant<quicktype::Alignof, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Alignof>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Alignof, double>>::to_json(json & j, const std::variant<quicktype::Alignof, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Alignof>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::And, double>>::from_json(const json & j, std::variant<quicktype::And, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::And>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::And, double>>::to_json(json & j, const std::variant<quicktype::And, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::And>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AndEq, double>>::from_json(const json & j, std::variant<quicktype::AndEq, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::AndEq>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AndEq, double>>::to_json(json & j, const std::variant<quicktype::AndEq, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::AndEq>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AnyClass, double>>::from_json(const json & j, std::variant<quicktype::AnyClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::AnyClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AnyClass, double>>::to_json(json & j, const std::variant<quicktype::AnyClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::AnyClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Asm, double>>::from_json(const json & j, std::variant<quicktype::Asm, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Asm>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Asm, double>>::to_json(json & j, const std::variant<quicktype::Asm, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Asm>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AtomicCancel, double>>::from_json(const json & j, std::variant<quicktype::AtomicCancel, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::AtomicCancel>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AtomicCancel, double>>::to_json(json & j, const std::variant<quicktype::AtomicCancel, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::AtomicCancel>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AtomicCommit, double>>::from_json(const json & j, std::variant<quicktype::AtomicCommit, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::AtomicCommit>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AtomicCommit, double>>::to_json(json & j, const std::variant<quicktype::AtomicCommit, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::AtomicCommit>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AtomicNoexcept, double>>::from_json(const json & j, std::variant<quicktype::AtomicNoexcept, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::AtomicNoexcept>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::AtomicNoexcept, double>>::to_json(json & j, const std::variant<quicktype::AtomicNoexcept, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::AtomicNoexcept>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Auto, double>>::from_json(const json & j, std::variant<quicktype::Auto, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Auto>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Auto, double>>::to_json(json & j, const std::variant<quicktype::Auto, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Auto>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bitand, double>>::from_json(const json & j, std::variant<quicktype::Bitand, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Bitand>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bitand, double>>::to_json(json & j, const std::variant<quicktype::Bitand, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Bitand>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bitor, double>>::from_json(const json & j, std::variant<quicktype::Bitor, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Bitor>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bitor, double>>::to_json(json & j, const std::variant<quicktype::Bitor, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Bitor>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bool, double>>::from_json(const json & j, std::variant<quicktype::Bool, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Bool>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Bool, double>>::to_json(json & j, const std::variant<quicktype::Bool, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Bool>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Break, double>>::from_json(const json & j, std::variant<quicktype::Break, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Break>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Break, double>>::to_json(json & j, const std::variant<quicktype::Break, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Break>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Case, double>>::from_json(const json & j, std::variant<quicktype::Case, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Case>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Case, double>>::to_json(json & j, const std::variant<quicktype::Case, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Case>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Catch, double>>::from_json(const json & j, std::variant<quicktype::Catch, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Catch>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Catch, double>>::to_json(json & j, const std::variant<quicktype::Catch, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Catch>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Char, double>>::from_json(const json & j, std::variant<quicktype::Char, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Char>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Char, double>>::to_json(json & j, const std::variant<quicktype::Char, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Char>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Char16T, double>>::from_json(const json & j, std::variant<quicktype::Char16T, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Char16T>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Char16T, double>>::to_json(json & j, const std::variant<quicktype::Char16T, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Char16T>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Char32T, double>>::from_json(const json & j, std::variant<quicktype::Char32T, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Char32T>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Char32T, double>>::to_json(json & j, const std::variant<quicktype::Char32T, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Char32T>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Class, double>>::from_json(const json & j, std::variant<quicktype::Class, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Class>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Class, double>>::to_json(json & j, const std::variant<quicktype::Class, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Class>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoAwait, double>>::from_json(const json & j, std::variant<quicktype::CoAwait, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CoAwait>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoAwait, double>>::to_json(json & j, const std::variant<quicktype::CoAwait, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CoAwait>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoReturn, double>>::from_json(const json & j, std::variant<quicktype::CoReturn, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CoReturn>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoReturn, double>>::to_json(json & j, const std::variant<quicktype::CoReturn, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CoReturn>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoYield, double>>::from_json(const json & j, std::variant<quicktype::CoYield, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::CoYield>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::CoYield, double>>::to_json(json & j, const std::variant<quicktype::CoYield, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::CoYield>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Compl, double>>::from_json(const json & j, std::variant<quicktype::Compl, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Compl>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Compl, double>>::to_json(json & j, const std::variant<quicktype::Compl, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Compl>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Concept, double>>::from_json(const json & j, std::variant<quicktype::Concept, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Concept>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Concept, double>>::to_json(json & j, const std::variant<quicktype::Concept, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Concept>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Const, double>>::from_json(const json & j, std::variant<quicktype::Const, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Const>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Const, double>>::to_json(json & j, const std::variant<quicktype::Const, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Const>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ConstCast, double>>::from_json(const json & j, std::variant<quicktype::ConstCast, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::ConstCast>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ConstCast, double>>::to_json(json & j, const std::variant<quicktype::ConstCast, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ConstCast>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Constexpr, double>>::from_json(const json & j, std::variant<quicktype::Constexpr, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Constexpr>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Constexpr, double>>::to_json(json & j, const std::variant<quicktype::Constexpr, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Constexpr>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Continue, double>>::from_json(const json & j, std::variant<quicktype::Continue, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Continue>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Continue, double>>::to_json(json & j, const std::variant<quicktype::Continue, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Continue>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Decltype, double>>::from_json(const json & j, std::variant<quicktype::Decltype, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Decltype>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Decltype, double>>::to_json(json & j, const std::variant<quicktype::Decltype, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Decltype>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Default, double>>::from_json(const json & j, std::variant<quicktype::Default, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Default>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Default, double>>::to_json(json & j, const std::variant<quicktype::Default, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Default>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Delete, double>>::from_json(const json & j, std::variant<quicktype::Delete, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Delete>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Delete, double>>::to_json(json & j, const std::variant<quicktype::Delete, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Delete>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Do, double>>::from_json(const json & j, std::variant<quicktype::Do, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Do>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Do, double>>::to_json(json & j, const std::variant<quicktype::Do, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Do>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Double, double>>::from_json(const json & j, std::variant<quicktype::Double, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Double>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Double, double>>::to_json(json & j, const std::variant<quicktype::Double, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Double>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DynamicCast, double>>::from_json(const json & j, std::variant<quicktype::DynamicCast, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::DynamicCast>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::DynamicCast, double>>::to_json(json & j, const std::variant<quicktype::DynamicCast, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::DynamicCast>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Else, double>>::from_json(const json & j, std::variant<quicktype::Else, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Else>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Else, double>>::to_json(json & j, const std::variant<quicktype::Else, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Else>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Enum, double>>::from_json(const json & j, std::variant<quicktype::Enum, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Enum>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Enum, double>>::to_json(json & j, const std::variant<quicktype::Enum, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Enum>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Explicit, double>>::from_json(const json & j, std::variant<quicktype::Explicit, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Explicit>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Explicit, double>>::to_json(json & j, const std::variant<quicktype::Explicit, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Explicit>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Export, double>>::from_json(const json & j, std::variant<quicktype::Export, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Export>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Export, double>>::to_json(json & j, const std::variant<quicktype::Export, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Export>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Extern, double>>::from_json(const json & j, std::variant<quicktype::Extern, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Extern>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Extern, double>>::to_json(json & j, const std::variant<quicktype::Extern, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Extern>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::False, double>>::from_json(const json & j, std::variant<quicktype::False, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::False>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::False, double>>::to_json(json & j, const std::variant<quicktype::False, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::False>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Final, double>>::from_json(const json & j, std::variant<quicktype::Final, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Final>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Final, double>>::to_json(json & j, const std::variant<quicktype::Final, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Final>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Float, double>>::from_json(const json & j, std::variant<quicktype::Float, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Float>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Float, double>>::to_json(json & j, const std::variant<quicktype::Float, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Float>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::For, double>>::from_json(const json & j, std::variant<quicktype::For, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::For>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::For, double>>::to_json(json & j, const std::variant<quicktype::For, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::For>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Friend, double>>::from_json(const json & j, std::variant<quicktype::Friend, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Friend>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Friend, double>>::to_json(json & j, const std::variant<quicktype::Friend, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Friend>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Goto, double>>::from_json(const json & j, std::variant<quicktype::Goto, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Goto>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Goto, double>>::to_json(json & j, const std::variant<quicktype::Goto, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Goto>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::If, double>>::from_json(const json & j, std::variant<quicktype::If, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::If>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::If, double>>::to_json(json & j, const std::variant<quicktype::If, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::If>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Import, double>>::from_json(const json & j, std::variant<quicktype::Import, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Import>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Import, double>>::to_json(json & j, const std::variant<quicktype::Import, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Import>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Inline, double>>::from_json(const json & j, std::variant<quicktype::Inline, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Inline>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Inline, double>>::to_json(json & j, const std::variant<quicktype::Inline, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Inline>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Int, double>>::from_json(const json & j, std::variant<quicktype::Int, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Int>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Int, double>>::to_json(json & j, const std::variant<quicktype::Int, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Int>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Long, double>>::from_json(const json & j, std::variant<quicktype::Long, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Long>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Long, double>>::to_json(json & j, const std::variant<quicktype::Long, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Long>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Module, double>>::from_json(const json & j, std::variant<quicktype::Module, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Module>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Module, double>>::to_json(json & j, const std::variant<quicktype::Module, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Module>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Mutable, double>>::from_json(const json & j, std::variant<quicktype::Mutable, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Mutable>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Mutable, double>>::to_json(json & j, const std::variant<quicktype::Mutable, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Mutable>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Namespace, double>>::from_json(const json & j, std::variant<quicktype::Namespace, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Namespace>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Namespace, double>>::to_json(json & j, const std::variant<quicktype::Namespace, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Namespace>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::New, double>>::from_json(const json & j, std::variant<quicktype::New, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::New>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::New, double>>::to_json(json & j, const std::variant<quicktype::New, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::New>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Noexcept, double>>::from_json(const json & j, std::variant<quicktype::Noexcept, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Noexcept>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Noexcept, double>>::to_json(json & j, const std::variant<quicktype::Noexcept, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Noexcept>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NoneClass, double>>::from_json(const json & j, std::variant<quicktype::NoneClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::NoneClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NoneClass, double>>::to_json(json & j, const std::variant<quicktype::NoneClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::NoneClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Not, double>>::from_json(const json & j, std::variant<quicktype::Not, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Not>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Not, double>>::to_json(json & j, const std::variant<quicktype::Not, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Not>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NotEq, double>>::from_json(const json & j, std::variant<quicktype::NotEq, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::NotEq>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NotEq, double>>::to_json(json & j, const std::variant<quicktype::NotEq, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::NotEq>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NullClass, double>>::from_json(const json & j, std::variant<quicktype::NullClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::NullClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::NullClass, double>>::to_json(json & j, const std::variant<quicktype::NullClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::NullClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nullptr, double>>::from_json(const json & j, std::variant<quicktype::Nullptr, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Nullptr>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Nullptr, double>>::to_json(json & j, const std::variant<quicktype::Nullptr, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Nullptr>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Operator, double>>::from_json(const json & j, std::variant<quicktype::Operator, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Operator>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Operator, double>>::to_json(json & j, const std::variant<quicktype::Operator, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Operator>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Or, double>>::from_json(const json & j, std::variant<quicktype::Or, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Or>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Or, double>>::to_json(json & j, const std::variant<quicktype::Or, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Or>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OrEq, double>>::from_json(const json & j, std::variant<quicktype::OrEq, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::OrEq>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::OrEq, double>>::to_json(json & j, const std::variant<quicktype::OrEq, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::OrEq>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Override, double>>::from_json(const json & j, std::variant<quicktype::Override, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Override>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Override, double>>::to_json(json & j, const std::variant<quicktype::Override, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Override>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Private, double>>::from_json(const json & j, std::variant<quicktype::Private, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Private>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Private, double>>::to_json(json & j, const std::variant<quicktype::Private, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Private>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Protected, double>>::from_json(const json & j, std::variant<quicktype::Protected, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Protected>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Protected, double>>::to_json(json & j, const std::variant<quicktype::Protected, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Protected>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ProtocolClass, double>>::from_json(const json & j, std::variant<quicktype::ProtocolClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::ProtocolClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ProtocolClass, double>>::to_json(json & j, const std::variant<quicktype::ProtocolClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ProtocolClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Public, double>>::from_json(const json & j, std::variant<quicktype::Public, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Public>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Public, double>>::to_json(json & j, const std::variant<quicktype::Public, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Public>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Register, double>>::from_json(const json & j, std::variant<quicktype::Register, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Register>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Register, double>>::to_json(json & j, const std::variant<quicktype::Register, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Register>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ReinterpretCast, double>>::from_json(const json & j, std::variant<quicktype::ReinterpretCast, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::ReinterpretCast>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ReinterpretCast, double>>::to_json(json & j, const std::variant<quicktype::ReinterpretCast, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ReinterpretCast>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Requires, double>>::from_json(const json & j, std::variant<quicktype::Requires, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Requires>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Requires, double>>::to_json(json & j, const std::variant<quicktype::Requires, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Requires>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Return, double>>::from_json(const json & j, std::variant<quicktype::Return, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Return>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Return, double>>::to_json(json & j, const std::variant<quicktype::Return, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Return>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SelfClass, double>>::from_json(const json & j, std::variant<quicktype::SelfClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::SelfClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::SelfClass, double>>::to_json(json & j, const std::variant<quicktype::SelfClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::SelfClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Short, double>>::from_json(const json & j, std::variant<quicktype::Short, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Short>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Short, double>>::to_json(json & j, const std::variant<quicktype::Short, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Short>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Signed, double>>::from_json(const json & j, std::variant<quicktype::Signed, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Signed>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Signed, double>>::to_json(json & j, const std::variant<quicktype::Signed, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Signed>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sizeof, double>>::from_json(const json & j, std::variant<quicktype::Sizeof, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Sizeof>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Sizeof, double>>::to_json(json & j, const std::variant<quicktype::Sizeof, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Sizeof>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Static, double>>::from_json(const json & j, std::variant<quicktype::Static, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Static>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Static, double>>::to_json(json & j, const std::variant<quicktype::Static, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Static>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::StaticAssert, double>>::from_json(const json & j, std::variant<quicktype::StaticAssert, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::StaticAssert>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::StaticAssert, double>>::to_json(json & j, const std::variant<quicktype::StaticAssert, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::StaticAssert>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::StaticCast, double>>::from_json(const json & j, std::variant<quicktype::StaticCast, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::StaticCast>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::StaticCast, double>>::to_json(json & j, const std::variant<quicktype::StaticCast, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::StaticCast>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Struct, double>>::from_json(const json & j, std::variant<quicktype::Struct, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Struct>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Struct, double>>::to_json(json & j, const std::variant<quicktype::Struct, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Struct>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Switch, double>>::from_json(const json & j, std::variant<quicktype::Switch, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Switch>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Switch, double>>::to_json(json & j, const std::variant<quicktype::Switch, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Switch>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Synchronized, double>>::from_json(const json & j, std::variant<quicktype::Synchronized, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Synchronized>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Synchronized, double>>::to_json(json & j, const std::variant<quicktype::Synchronized, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Synchronized>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Template, double>>::from_json(const json & j, std::variant<quicktype::Template, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Template>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Template, double>>::to_json(json & j, const std::variant<quicktype::Template, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Template>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::This, double>>::from_json(const json & j, std::variant<quicktype::This, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::This>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::This, double>>::to_json(json & j, const std::variant<quicktype::This, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::This>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ThreadLocal, double>>::from_json(const json & j, std::variant<quicktype::ThreadLocal, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::ThreadLocal>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::ThreadLocal, double>>::to_json(json & j, const std::variant<quicktype::ThreadLocal, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::ThreadLocal>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Throw, double>>::from_json(const json & j, std::variant<quicktype::Throw, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Throw>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Throw, double>>::to_json(json & j, const std::variant<quicktype::Throw, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Throw>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::True, double>>::from_json(const json & j, std::variant<quicktype::True, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::True>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::True, double>>::to_json(json & j, const std::variant<quicktype::True, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::True>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Try, double>>::from_json(const json & j, std::variant<quicktype::Try, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Try>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Try, double>>::to_json(json & j, const std::variant<quicktype::Try, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Try>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::TypeClass, double>>::from_json(const json & j, std::variant<quicktype::TypeClass, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::TypeClass>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::TypeClass, double>>::to_json(json & j, const std::variant<quicktype::TypeClass, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::TypeClass>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typedef, double>>::from_json(const json & j, std::variant<quicktype::Typedef, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Typedef>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typedef, double>>::to_json(json & j, const std::variant<quicktype::Typedef, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Typedef>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typeid, double>>::from_json(const json & j, std::variant<quicktype::Typeid, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Typeid>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typeid, double>>::to_json(json & j, const std::variant<quicktype::Typeid, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Typeid>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typename, double>>::from_json(const json & j, std::variant<quicktype::Typename, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Typename>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typename, double>>::to_json(json & j, const std::variant<quicktype::Typename, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Typename>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Union, double>>::from_json(const json & j, std::variant<quicktype::Union, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Union>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Union, double>>::to_json(json & j, const std::variant<quicktype::Union, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Union>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unsigned, double>>::from_json(const json & j, std::variant<quicktype::Unsigned, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Unsigned>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unsigned, double>>::to_json(json & j, const std::variant<quicktype::Unsigned, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Unsigned>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Using, double>>::from_json(const json & j, std::variant<quicktype::Using, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Using>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Using, double>>::to_json(json & j, const std::variant<quicktype::Using, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Using>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Virtual, double>>::from_json(const json & j, std::variant<quicktype::Virtual, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Virtual>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Virtual, double>>::to_json(json & j, const std::variant<quicktype::Virtual, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Virtual>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Void, double>>::from_json(const json & j, std::variant<quicktype::Void, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Void>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Void, double>>::to_json(json & j, const std::variant<quicktype::Void, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Void>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Volatile, double>>::from_json(const json & j, std::variant<quicktype::Volatile, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Volatile>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Volatile, double>>::to_json(json & j, const std::variant<quicktype::Volatile, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Volatile>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::WcharT, double>>::from_json(const json & j, std::variant<quicktype::WcharT, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::WcharT>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::WcharT, double>>::to_json(json & j, const std::variant<quicktype::WcharT, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::WcharT>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::While, double>>::from_json(const json & j, std::variant<quicktype::While, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::While>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::While, double>>::to_json(json & j, const std::variant<quicktype::While, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::While>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Xor, double>>::from_json(const json & j, std::variant<quicktype::Xor, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Xor>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Xor, double>>::to_json(json & j, const std::variant<quicktype::Xor, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Xor>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::XorEq, double>>::from_json(const json & j, std::variant<quicktype::XorEq, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::XorEq>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::XorEq, double>>::to_json(json & j, const std::variant<quicktype::XorEq, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::XorEq>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Transient, double>>::from_json(const json & j, std::variant<quicktype::Transient, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Transient>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Transient, double>>::to_json(json & j, const std::variant<quicktype::Transient, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Transient>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Type, double>>::from_json(const json & j, std::variant<quicktype::Type, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Type>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Type, double>>::to_json(json & j, const std::variant<quicktype::Type, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Type>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typealias, double>>::from_json(const json & j, std::variant<quicktype::Typealias, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Typealias>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typealias, double>>::to_json(json & j, const std::variant<quicktype::Typealias, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Typealias>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typeof, double>>::from_json(const json & j, std::variant<quicktype::Typeof, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Typeof>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Typeof, double>>::to_json(json & j, const std::variant<quicktype::Typeof, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Typeof>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Uint, double>>::from_json(const json & j, std::variant<quicktype::Uint, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Uint>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Uint, double>>::to_json(json & j, const std::variant<quicktype::Uint, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Uint>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Ulong, double>>::from_json(const json & j, std::variant<quicktype::Ulong, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Ulong>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Ulong, double>>::to_json(json & j, const std::variant<quicktype::Ulong, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Ulong>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unchecked, double>>::from_json(const json & j, std::variant<quicktype::Unchecked, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Unchecked>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unchecked, double>>::to_json(json & j, const std::variant<quicktype::Unchecked, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Unchecked>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Undefined, double>>::from_json(const json & j, std::variant<quicktype::Undefined, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Undefined>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Undefined, double>>::to_json(json & j, const std::variant<quicktype::Undefined, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Undefined>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unowned, double>>::from_json(const json & j, std::variant<quicktype::Unowned, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Unowned>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unowned, double>>::to_json(json & j, const std::variant<quicktype::Unowned, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Unowned>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unsafe, double>>::from_json(const json & j, std::variant<quicktype::Unsafe, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Unsafe>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Unsafe, double>>::to_json(json & j, const std::variant<quicktype::Unsafe, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Unsafe>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Ushort, double>>::from_json(const json & j, std::variant<quicktype::Ushort, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Ushort>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Ushort, double>>::to_json(json & j, const std::variant<quicktype::Ushort, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Ushort>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Var, double>>::from_json(const json & j, std::variant<quicktype::Var, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Var>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Var, double>>::to_json(json & j, const std::variant<quicktype::Var, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Var>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Weak, double>>::from_json(const json & j, std::variant<quicktype::Weak, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Weak>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Weak, double>>::to_json(json & j, const std::variant<quicktype::Weak, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Weak>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Where, double>>::from_json(const json & j, std::variant<quicktype::Where, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Where>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Where, double>>::to_json(json & j, const std::variant<quicktype::Where, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Where>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::WillSet, double>>::from_json(const json & j, std::variant<quicktype::WillSet, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::WillSet>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::WillSet, double>>::to_json(json & j, const std::variant<quicktype::WillSet, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::WillSet>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::With, double>>::from_json(const json & j, std::variant<quicktype::With, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::With>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::With, double>>::to_json(json & j, const std::variant<quicktype::With, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::With>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Yes, double>>::from_json(const json & j, std::variant<quicktype::Yes, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Yes>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Yes, double>>::to_json(json & j, const std::variant<quicktype::Yes, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Yes>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Yield, double>>::from_json(const json & j, std::variant<quicktype::Yield, double> & x) {
+        if (j.is_number())
+            x = j.get<double>();
+        else if (j.is_object())
+            x = j.get<quicktype::Yield>();
+        else throw std::runtime_error("Could not deserialise!");
+    }
+
+    inline void adl_serializer<std::variant<quicktype::Yield, double>>::to_json(json & j, const std::variant<quicktype::Yield, double> & x) {
+        switch (x.index()) {
+            case 0:
+                j = std::get<quicktype::Yield>(x);
+                break;
+            case 1:
+                j = std::get<double>(x);
+                break;
+            default: throw std::runtime_error("Input JSON does not conform to schema!");
+        }
+    }
+}
diff --git a/head/schema-crystal/test/inputs/schema/accessors.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/accessors.schema/default/TopLevel.cr
new file mode 100644
index 0000000..7353e93
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/accessors.schema/default/TopLevel.cr
@@ -0,0 +1,18 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "bar")]
+  property barre : String
+
+  @[JSON::Field(key: "enum")]
+  property enumerification : String
+
+  property foo : String
+
+  @[JSON::Field(key: "union")]
+  property unionization : UnionUnion
+end
+
+alias UnionUnion = Float64 | Bool
diff --git a/head/schema-crystal/test/inputs/schema/any.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/any.schema/default/TopLevel.cr
new file mode 100644
index 0000000..c86458c
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/any.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : JSON::Any?
+
+  property values : Hash(String, JSON::Any?)
+end
diff --git a/head/schema-crystal/test/inputs/schema/bool-string.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/bool-string.schema/default/TopLevel.cr
new file mode 100644
index 0000000..3514cb4
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/bool-string.schema/default/TopLevel.cr
@@ -0,0 +1,25 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "arrNullable")]
+  property arr_nullable : Array(String?)?
+
+  @[JSON::Field(key: "arrOne")]
+  property arr_one : Array(String)?
+
+  property nullable : String?
+
+  property one : String
+
+  property optional : String?
+
+  @[JSON::Field(key: "unionWithBool")]
+  property union_with_bool : UnionWithBool
+
+  @[JSON::Field(key: "unionWithBoolAndEnum")]
+  property union_with_bool_and_enum : UnionWithBool
+end
+
+alias UnionWithBool = Bool | String
diff --git a/head/schema-crystal/test/inputs/schema/boolean-subschema.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/boolean-subschema.schema/default/TopLevel.cr
new file mode 100644
index 0000000..a844cb0
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/boolean-subschema.schema/default/TopLevel.cr
@@ -0,0 +1,13 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property disallowed : JSON::Any?
+
+  property empty : Array(JSON::Any?)
+
+  property foo : String
+
+  property impossible : JSON::Any?
+end
diff --git a/head/schema-crystal/test/inputs/schema/camelCase.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/camelCase.schema/default/TopLevel.cr
new file mode 100644
index 0000000..219225b
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/camelCase.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "myProperty")]
+  property my_property : String?
+
+  @[JSON::Field(key: "secondProperty")]
+  property second_property : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/class-map-union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/class-map-union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..b5ff3d7
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/class-map-union.schema/default/TopLevel.cr
@@ -0,0 +1,16 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "union")]
+  property top_level_union : Hash(String, UnionValue)?
+end
+
+class UnionClass
+  include JSON::Serializable
+
+  property quux : Int32?
+end
+
+alias UnionValue = Float64 | Bool | String | UnionClass
diff --git a/head/schema-crystal/test/inputs/schema/class-with-additional.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/class-with-additional.schema/default/TopLevel.cr
new file mode 100644
index 0000000..2ccf680
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/class-with-additional.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property map : Hash(String, Map)?
+end
+
+alias Map = Float64 | Bool
diff --git a/head/schema-crystal/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.cr
new file mode 100644
index 0000000..b243f54
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  # Nested enum block comment openers:
+  # {-
+  # /*
+  # This text must remain inside the generated enum documentation comment.
+  property kind : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.cr
new file mode 100644
index 0000000..f713b81
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.cr
@@ -0,0 +1,14 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  # Comment delimiters:
+  # */
+  # {-
+  # -}
+  # """
+  # }
+  # }
+  property kind : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.cr
new file mode 100644
index 0000000..2483921
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+# Nested block comment openers:
+# {-
+# /*
+# This text must remain inside the generated documentation comment.
+class TopLevel
+  include JSON::Serializable
+
+  # Nested property block comment openers:
+  # {-
+  # /*
+  # This text must remain inside the generated property documentation comment.
+  property value : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/comment-injection.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/comment-injection.schema/default/TopLevel.cr
new file mode 100644
index 0000000..9ec5b9d
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/comment-injection.schema/default/TopLevel.cr
@@ -0,0 +1,43 @@
+require "json"
+
+# Comment delimiters:
+# */
+# /*
+# {-
+# -}
+# """
+# </summary> & <br>
+# }
+# }
+# }
+# }
+# }
+class TopLevel
+  include JSON::Serializable
+
+  # Ends with a backslash \
+  @[JSON::Field(key: "trailingBackslash")]
+  property trailing_backslash : String?
+
+  # Ends with a quote "
+  @[JSON::Field(key: "trailingQuote")]
+  property trailing_quote : String?
+
+  # Ends with a triple quote """
+  @[JSON::Field(key: "trailingTripleQuote")]
+  property trailing_triple_quote : String?
+
+  # Property delimiters:
+  # */
+  # /*
+  # {-
+  # -}
+  # """
+  # </summary> & <br>
+  # }
+  # }
+  # }
+  # }
+  # }
+  property value : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/constructor.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/constructor.schema/default/TopLevel.cr
new file mode 100644
index 0000000..cea8515
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/constructor.schema/default/TopLevel.cr
@@ -0,0 +1,14 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property constructor : UnionConstructor?
+end
+
+class Constructor
+  include JSON::Serializable
+
+end
+
+alias UnionConstructor = Constructor | Float64
diff --git a/head/schema-crystal/test/inputs/schema/cut-enum.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/cut-enum.schema/default/TopLevel.cr
new file mode 100644
index 0000000..ed03ea1
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/cut-enum.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/date-time-or-string.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/date-time-or-string.schema/default/TopLevel.cr
new file mode 100644
index 0000000..e21115f
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/date-time-or-string.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property bar : String
+
+  property foo : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/date-time.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/date-time.schema/default/TopLevel.cr
new file mode 100644
index 0000000..c145352
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/date-time.schema/default/TopLevel.cr
@@ -0,0 +1,20 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "complex-union-array")]
+  property complex_union_array : Array(ComplexUnionArray)
+
+  property date : String
+
+  @[JSON::Field(key: "date-time")]
+  property date_time : String
+
+  property time : String
+
+  @[JSON::Field(key: "union-array")]
+  property union_array : Array(String)
+end
+
+alias ComplexUnionArray = Int32 | String
diff --git a/head/schema-crystal/test/inputs/schema/default-value.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/default-value.schema/default/TopLevel.cr
new file mode 100644
index 0000000..884f630
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/default-value.schema/default/TopLevel.cr
@@ -0,0 +1,8 @@
+require "json"
+
+# An object with a scalar default
+class TopLevel
+  include JSON::Serializable
+
+  property id : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.cr
new file mode 100644
index 0000000..023f928
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.cr
@@ -0,0 +1,8 @@
+require "json"
+
+# Cool "stuff"
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Bool?
+end
diff --git a/head/schema-crystal/test/inputs/schema/description.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/description.schema/default/TopLevel.cr
new file mode 100644
index 0000000..3db424e
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/description.schema/default/TopLevel.cr
@@ -0,0 +1,35 @@
+require "json"
+
+# The top-level class.
+# Its description has two lines.
+class TopLevel
+  include JSON::Serializable
+
+  # A pretty boolean
+  property bar : Bool?
+
+  # An enumeration
+  @[JSON::Field(key: "enum")]
+  property top_level_enum : String
+
+  property foo : Float64?
+
+  @[JSON::Field(key: "object-or-string")]
+  property object_or_string : ObjectOrStringUnion
+
+  # Either a number or a string
+  @[JSON::Field(key: "union")]
+  property top_level_union : UnionUnion
+end
+
+class ObjectOrStringClass
+  include JSON::Serializable
+
+  # This must not get lost
+  property prop : Float64
+end
+
+alias ObjectOrStringUnion = ObjectOrStringClass | String
+
+# Either a number or a string
+alias UnionUnion = Float64 | String
diff --git a/head/schema-crystal/test/inputs/schema/direct-union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/direct-union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..d0e6576
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/direct-union.schema/default/TopLevel.cr
@@ -0,0 +1,17 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property stuff : Hash(String, Thing)
+end
+
+class Thing
+  include JSON::Serializable
+
+  property optional : Anything?
+
+  property required : Anything?
+end
+
+alias Anything = Array(JSON::Any?) | Hash(String, JSON::Any?) | Float64 | Int32 | Bool | String
diff --git a/head/schema-crystal/test/inputs/schema/empty-object.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/empty-object.schema/default/TopLevel.cr
new file mode 100644
index 0000000..b91bdf1
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/empty-object.schema/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Hash(String, JSON::Any?)
diff --git a/head/schema-crystal/test/inputs/schema/enum-with-null.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/enum-with-null.schema/default/TopLevel.cr
new file mode 100644
index 0000000..add12eb
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/enum-with-null.schema/default/TopLevel.cr
@@ -0,0 +1,8 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "enum")]
+  property top_level_enum : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/enum-with-values.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/enum-with-values.schema/default/TopLevel.cr
new file mode 100644
index 0000000..1e8406a
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/enum-with-values.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property weekdays : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.cr
new file mode 100644
index 0000000..5e48e8d
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property map : Hash(String, Int32)
+end
diff --git a/head/schema-crystal/test/inputs/schema/id-no-address.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/id-no-address.schema/default/TopLevel.cr
new file mode 100644
index 0000000..e1d04b2
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/id-no-address.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property item : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/id-root.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/id-root.schema/default/TopLevel.cr
new file mode 100644
index 0000000..096f325
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/id-root.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property bar : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.cr
new file mode 100644
index 0000000..c4b2352
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property cookies : Array(Cookie)
+end
+
+class Cookie
+  include JSON::Serializable
+
+  property name : String
+
+  property value : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/implicit-all-of.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/implicit-all-of.schema/default/TopLevel.cr
new file mode 100644
index 0000000..bc6b823
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/implicit-all-of.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Int32
+
+  property bar : Bool
+
+  property quux : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..e94cb82
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : FooUnion?
+end
+
+class FooClass
+  include JSON::Serializable
+
+  property bar : Int32
+end
+
+alias FooUnion = Float64 | FooClass | Int32 | Array(Int32) | Bool | String
diff --git a/head/schema-crystal/test/inputs/schema/implicit-one-of.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/implicit-one-of.schema/default/TopLevel.cr
new file mode 100644
index 0000000..58e6974
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/implicit-one-of.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Int32
+
+  property bar : Bool?
+
+  property quux : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/integer-before-number.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/integer-before-number.schema/default/TopLevel.cr
new file mode 100644
index 0000000..2cd4622
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/integer-before-number.schema/default/TopLevel.cr
@@ -0,0 +1,4 @@
+require "json"
+
+# An integer or non-integer number
+alias TopLevel = Float64 | Int32
diff --git a/head/schema-crystal/test/inputs/schema/integer-float-union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/integer-float-union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..d491fc9
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/integer-float-union.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property number : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/integer-string.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/integer-string.schema/default/TopLevel.cr
new file mode 100644
index 0000000..1e9fbec
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/integer-string.schema/default/TopLevel.cr
@@ -0,0 +1,25 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "arrNullable")]
+  property arr_nullable : Array(String?)?
+
+  @[JSON::Field(key: "arrOne")]
+  property arr_one : Array(String)?
+
+  property nullable : String?
+
+  property one : String
+
+  property optional : String?
+
+  @[JSON::Field(key: "unionWithInt")]
+  property union_with_int : UnionWithInt
+
+  @[JSON::Field(key: "unionWithIntAndEnum")]
+  property union_with_int_and_enum : UnionWithInt
+end
+
+alias UnionWithInt = Int32 | String
diff --git a/head/schema-crystal/test/inputs/schema/intersection-nested.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/intersection-nested.schema/default/TopLevel.cr
new file mode 100644
index 0000000..bbdd217
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/intersection-nested.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property intersection : Float64?
+end
diff --git a/head/schema-crystal/test/inputs/schema/intersection.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/intersection.schema/default/TopLevel.cr
new file mode 100644
index 0000000..89be215
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/intersection.schema/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property intersection : Intersection?
+end
+
+class Intersection
+  include JSON::Serializable
+
+  property foo : Float64
+
+  property bar : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.cr
new file mode 100644
index 0000000..8607039
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Array(Int32)
diff --git a/head/schema-crystal/test/inputs/schema/keyword-enum.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/keyword-enum.schema/default/TopLevel.cr
new file mode 100644
index 0000000..add12eb
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/keyword-enum.schema/default/TopLevel.cr
@@ -0,0 +1,8 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "enum")]
+  property top_level_enum : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/light.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/light.schema/default/TopLevel.cr
new file mode 100644
index 0000000..eacd2b5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/light.schema/default/TopLevel.cr
@@ -0,0 +1,18 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "LightParams")]
+  property light_params : LightParams
+end
+
+class LightParams
+  include JSON::Serializable
+
+  property app_id : String
+
+  property outlet_id : String
+
+  property rgba : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/list.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/list.schema/default/TopLevel.cr
new file mode 100644
index 0000000..1537ac5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/list.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+# A recursive class type
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : TopLevel?
+end
diff --git a/head/schema-crystal/test/inputs/schema/min-max-items.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/min-max-items.schema/default/TopLevel.cr
new file mode 100644
index 0000000..11dada5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/min-max-items.schema/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "maxOnly")]
+  property max_only : Array(Int32)
+
+  @[JSON::Field(key: "minAndMax")]
+  property min_and_max : Array(Float64)
+
+  @[JSON::Field(key: "minOnly")]
+  property min_only : Array(String)
+
+  property plain : Array(String)
+
+  @[JSON::Field(key: "unionItems")]
+  property union_items : Array(UnionItem)
+end
+
+alias UnionItem = Int32 | String
diff --git a/head/schema-crystal/test/inputs/schema/minmax-integer.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/minmax-integer.schema/default/TopLevel.cr
new file mode 100644
index 0000000..83b4fbf
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/minmax-integer.schema/default/TopLevel.cr
@@ -0,0 +1,24 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property free : Int32
+
+  property intersection : Int32
+
+  property max : Int32
+
+  property min : Int32
+
+  property minmax : Int32
+
+  @[JSON::Field(key: "minMaxIntersection")]
+  property min_max_intersection : Int32
+
+  @[JSON::Field(key: "minMaxUnion")]
+  property min_max_union : Int32
+
+  @[JSON::Field(key: "union")]
+  property top_level_union : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/minmax.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/minmax.schema/default/TopLevel.cr
new file mode 100644
index 0000000..9d4ab2a
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/minmax.schema/default/TopLevel.cr
@@ -0,0 +1,24 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property free : Float64
+
+  property intersection : Float64
+
+  property max : Float64
+
+  property min : Float64
+
+  property minmax : Float64
+
+  @[JSON::Field(key: "minMaxIntersection")]
+  property min_max_intersection : Float64
+
+  @[JSON::Field(key: "minMaxUnion")]
+  property min_max_union : Float64
+
+  @[JSON::Field(key: "union")]
+  property top_level_union : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/minmaxlength.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/minmaxlength.schema/default/TopLevel.cr
new file mode 100644
index 0000000..c72c6e3
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/minmaxlength.schema/default/TopLevel.cr
@@ -0,0 +1,27 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property intersection : String
+
+  @[JSON::Field(key: "inUnion")]
+  property in_union : InUnion
+
+  property maxlength : String
+
+  property minlength : String
+
+  @[JSON::Field(key: "minMaxIntersection")]
+  property min_max_intersection : String
+
+  property minmaxlength : String
+
+  @[JSON::Field(key: "minMaxUnion")]
+  property min_max_union : String
+
+  @[JSON::Field(key: "union")]
+  property top_level_union : String
+end
+
+alias InUnion = Float64 | String
diff --git a/head/schema-crystal/test/inputs/schema/multi-type-enum.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/multi-type-enum.schema/default/TopLevel.cr
new file mode 100644
index 0000000..529c7c5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/multi-type-enum.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : FooUnion
+end
+
+alias FooUnion = Float64 | Bool | String
diff --git a/head/schema-crystal/test/inputs/schema/mutually-recursive.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/mutually-recursive.schema/default/TopLevel.cr
new file mode 100644
index 0000000..3d03f75
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/mutually-recursive.schema/default/TopLevel.cr
@@ -0,0 +1,15 @@
+require "json"
+
+class Bar
+  include JSON::Serializable
+
+  property foo : Foo
+end
+
+class TopLevel
+  include JSON::Serializable
+
+  property bar : Bar?
+end
+
+alias Foo = TopLevel | Array(TopLevel)
diff --git a/head/schema-crystal/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..be4b5eb
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.cr
@@ -0,0 +1,19 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property input : Array(Item)
+end
+
+class Item
+  include JSON::Serializable
+
+  property content : String?
+
+  property id : String?
+
+  property output : String?
+
+  property summary : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/non-standard-ref.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/non-standard-ref.schema/default/TopLevel.cr
new file mode 100644
index 0000000..d2d3d6d
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/non-standard-ref.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property bar : Int32
+
+  property foo : Int32
+
+  property quux : Bool
+end
diff --git a/head/schema-crystal/test/inputs/schema/object-type-required.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/object-type-required.schema/default/TopLevel.cr
new file mode 100644
index 0000000..170be21
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/object-type-required.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : String
+
+  property bar : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/optional-any.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/optional-any.schema/default/TopLevel.cr
new file mode 100644
index 0000000..bea26e0
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/optional-any.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property bar : Bool
+
+  property foo : JSON::Any?
+end
diff --git a/head/schema-crystal/test/inputs/schema/optional-const-ref.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/optional-const-ref.schema/default/TopLevel.cr
new file mode 100644
index 0000000..eeaba72
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/optional-const-ref.schema/default/TopLevel.cr
@@ -0,0 +1,30 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property coordinates : Array(Coordinate)?
+
+  property count : Int32?
+
+  property label : String?
+
+  @[JSON::Field(key: "requiredCoordinates")]
+  property required_coordinates : Array(Coordinate)
+
+  @[JSON::Field(key: "requiredCount")]
+  property required_count : Int32
+
+  @[JSON::Field(key: "requiredLabel")]
+  property required_label : String
+
+  property weight : Float64?
+end
+
+class Coordinate
+  include JSON::Serializable
+
+  property latitude : Float64
+
+  property longitude : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/optional-constraints.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/optional-constraints.schema/default/TopLevel.cr
new file mode 100644
index 0000000..6e81b73
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/optional-constraints.schema/default/TopLevel.cr
@@ -0,0 +1,20 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "optDouble")]
+  property opt_double : Float64?
+
+  @[JSON::Field(key: "optInt")]
+  property opt_int : Int32?
+
+  @[JSON::Field(key: "optPattern")]
+  property opt_pattern : String?
+
+  @[JSON::Field(key: "optString")]
+  property opt_string : String?
+
+  @[JSON::Field(key: "reqZeroMin")]
+  property req_zero_min : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/optional-date-time.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/optional-date-time.schema/default/TopLevel.cr
new file mode 100644
index 0000000..e73b27c
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/optional-date-time.schema/default/TopLevel.cr
@@ -0,0 +1,23 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "optional-date")]
+  property optional_date : String?
+
+  @[JSON::Field(key: "optional-date-time")]
+  property optional_date_time : String?
+
+  @[JSON::Field(key: "optional-time")]
+  property optional_time : String?
+
+  @[JSON::Field(key: "required-date")]
+  property required_date : String
+
+  @[JSON::Field(key: "required-date-time")]
+  property required_date_time : String
+
+  @[JSON::Field(key: "required-time")]
+  property required_time : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/optional-enum.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/optional-enum.schema/default/TopLevel.cr
new file mode 100644
index 0000000..6fd3b9c
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/optional-enum.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property name : String
+
+  property shortcut : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/pattern.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/pattern.schema/default/TopLevel.cr
new file mode 100644
index 0000000..b830f0d
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/pattern.schema/default/TopLevel.cr
@@ -0,0 +1,12 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property pattern1 : String
+
+  property pattern2 : String
+
+  @[JSON::Field(key: "union")]
+  property top_level_union : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/postman-collection.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/postman-collection.schema/default/TopLevel.cr
new file mode 100644
index 0000000..3c60958
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/postman-collection.schema/default/TopLevel.cr
@@ -0,0 +1,18 @@
+require "json"
+
+# Postman collection
+class TopLevel
+  include JSON::Serializable
+
+  property item : Array(TopLevel)?
+
+  property name : String?
+
+  property response : Array(Response)?
+end
+
+class Response
+  include JSON::Serializable
+
+  property body : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/prefix-items.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/prefix-items.schema/default/TopLevel.cr
new file mode 100644
index 0000000..7dddcd5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/prefix-items.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property open : Array(Open)
+
+  property tuple : Array(Open)
+end
+
+alias Open = Int32 | Bool
diff --git a/head/schema-crystal/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.cr
new file mode 100644
index 0000000..181fa49
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevelClass
+  include JSON::Serializable
+
+  property x : X?
+end
+
+class XClass
+  include JSON::Serializable
+
+  property x : X?
+end
+
+alias TopLevel = Hash(String, JSON::Any?) | Float64 | Int32 | Bool | String | Array(TopLevelElement?)
+
+alias TopLevelElement = Array(JSON::Any?) | Float64 | Bool | String | TopLevelClass
+
+alias XElement = Array(JSON::Any?) | Float64 | Bool | String | XClass
+
+alias X = Hash(String, JSON::Any?) | Float64 | Bool | String | Array(XElement?)
diff --git a/head/schema-crystal/test/inputs/schema/ref-id-files.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/ref-id-files.schema/default/TopLevel.cr
new file mode 100644
index 0000000..ed03ea1
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/ref-id-files.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Int32
+end
diff --git a/head/schema-crystal/test/inputs/schema/ref-remote.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/ref-remote.schema/default/TopLevel.cr
new file mode 100644
index 0000000..1537ac5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/ref-remote.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+# A recursive class type
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : TopLevel?
+end
diff --git a/head/schema-crystal/test/inputs/schema/renaming-bug.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/renaming-bug.schema/default/TopLevel.cr
new file mode 100644
index 0000000..7226488
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/renaming-bug.schema/default/TopLevel.cr
@@ -0,0 +1,127 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property version : String?
+
+  property fruits : Array(Fruit)?
+
+  property vehicles : Array(Vehicle)?
+end
+
+class Fruit
+  include JSON::Serializable
+
+  property apple : Bool?
+
+  property berries : Array(Berry)?
+
+  property orange : Bool?
+end
+
+class Berry
+  include JSON::Serializable
+
+  property color : Color?
+
+  property name : String?
+
+  property shapes : Array(Shape)?
+end
+
+class Color
+  include JSON::Serializable
+
+  property rgb : Float64?
+end
+
+class Shape
+  include JSON::Serializable
+
+  property geometry : Geometry?
+
+  property history : History?
+end
+
+class Geometry
+  include JSON::Serializable
+
+  @[JSON::Field(key: "rectShape")]
+  property rect_shape : RectShape?
+
+  @[JSON::Field(key: "circularShape")]
+  property circular_shape : Array(CircularShape)?
+end
+
+class CircularShape
+  include JSON::Serializable
+
+  @[JSON::Field(key: "shapeName")]
+  property shape_name : String?
+end
+
+class RectShape
+  include JSON::Serializable
+
+  property parts : Array(Part)?
+end
+
+class Part
+  include JSON::Serializable
+
+  property depth : String?
+
+  property length : String?
+
+  property width : String?
+end
+
+class History
+  include JSON::Serializable
+
+  @[JSON::Field(key: "class")]
+  property history_class : String?
+end
+
+class Vehicle
+  include JSON::Serializable
+
+  property brand : String?
+
+  property id : String?
+
+  property speed : Speed?
+
+  @[JSON::Field(key: "subModule")]
+  property sub_module : Bool?
+
+  @[JSON::Field(key: "type")]
+  property vehicle_type : VehicleType?
+
+  property year : String?
+end
+
+class Speed
+  include JSON::Serializable
+
+  property velocity : Limit?
+end
+
+class Limit
+  include JSON::Serializable
+
+  property maximum : Float64?
+
+  property minimum : Float64?
+end
+
+class VehicleType
+  include JSON::Serializable
+
+  property name : String?
+
+  property width : String?
+
+  property length : String?
+end
diff --git a/head/schema-crystal/test/inputs/schema/required-draft3.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/required-draft3.schema/default/TopLevel.cr
new file mode 100644
index 0000000..99ab3cb
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/required-draft3.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property longitude : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/required-non-properties.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/required-non-properties.schema/default/TopLevel.cr
new file mode 100644
index 0000000..07d4dad
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/required-non-properties.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Int32
+
+  property bar : JSON::Any?
+end
diff --git a/head/schema-crystal/test/inputs/schema/required.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/required.schema/default/TopLevel.cr
new file mode 100644
index 0000000..99ab3cb
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/required.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property longitude : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..9c80050
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.cr
@@ -0,0 +1,21 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : Next?
+
+  property value : String
+end
+
+class Node
+  include JSON::Serializable
+
+  @[JSON::Field(key: "next")]
+  property node_next : Next?
+
+  property value : String
+end
+
+alias Next = Node | String
diff --git a/head/schema-crystal/test/inputs/schema/schema-constraints.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/schema-constraints.schema/default/TopLevel.cr
new file mode 100644
index 0000000..d12e9e3
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/schema-constraints.schema/default/TopLevel.cr
@@ -0,0 +1,10 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "minMaxLength")]
+  property min_max_length : String
+
+  property percent : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/simple-ref.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/simple-ref.schema/default/TopLevel.cr
new file mode 100644
index 0000000..1537ac5
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/simple-ref.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+# A recursive class type
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "next")]
+  property top_level_next : TopLevel?
+end
diff --git a/head/schema-crystal/test/inputs/schema/strict-optional.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/strict-optional.schema/default/TopLevel.cr
new file mode 100644
index 0000000..bcc65c8
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/strict-optional.schema/default/TopLevel.cr
@@ -0,0 +1,7 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property foo : Float64?
+end
diff --git a/head/schema-crystal/test/inputs/schema/top-level-array.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/top-level-array.schema/default/TopLevel.cr
new file mode 100644
index 0000000..eda2a8a
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/top-level-array.schema/default/TopLevel.cr
@@ -0,0 +1,11 @@
+require "json"
+
+alias TopLevel = Array(TextClassificationOutputElement)
+
+class TextClassificationOutputElement
+  include JSON::Serializable
+
+  property label : String
+
+  property score : Float64
+end
diff --git a/head/schema-crystal/test/inputs/schema/top-level-enum.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/top-level-enum.schema/default/TopLevel.cr
new file mode 100644
index 0000000..410ef97
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/top-level-enum.schema/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = String
diff --git a/head/schema-crystal/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.cr
new file mode 100644
index 0000000..2f8f42d
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Array(String)
diff --git a/head/schema-crystal/test/inputs/schema/top-level-primitive.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/top-level-primitive.schema/default/TopLevel.cr
new file mode 100644
index 0000000..c5d3d5b
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/top-level-primitive.schema/default/TopLevel.cr
@@ -0,0 +1,3 @@
+require "json"
+
+alias TopLevel = Float64
diff --git a/head/schema-crystal/test/inputs/schema/tuple.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/tuple.schema/default/TopLevel.cr
new file mode 100644
index 0000000..2f2a411
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/tuple.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property tuple : Array(TupleElement)
+end
+
+alias TupleElement = Int32 | Bool
diff --git a/head/schema-crystal/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.cr
new file mode 100644
index 0000000..9c408be
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.cr
@@ -0,0 +1,32 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property config : Config?
+end
+
+class Config
+  include JSON::Serializable
+
+  property closed : Closed?
+
+  property name : String?
+
+  property settings : Hash(String, Array(Item))?
+end
+
+class ClosedClass
+  include JSON::Serializable
+
+end
+
+class Item
+  include JSON::Serializable
+
+  property key : String
+
+  property value : String
+end
+
+alias Closed = Array(JSON::Any?) | ClosedClass | Float64 | Int32 | Bool | String
diff --git a/head/schema-crystal/test/inputs/schema/union-int-double.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/union-int-double.schema/default/TopLevel.cr
new file mode 100644
index 0000000..29121bc
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/union-int-double.schema/default/TopLevel.cr
@@ -0,0 +1,9 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property value : ValueUnion
+end
+
+alias ValueUnion = Float64 | String
diff --git a/head/schema-crystal/test/inputs/schema/union-list.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/union-list.schema/default/TopLevel.cr
new file mode 100644
index 0000000..a23ff7b
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/union-list.schema/default/TopLevel.cr
@@ -0,0 +1,16 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  property list : UnionList
+end
+
+class UnionListClass
+  include JSON::Serializable
+
+  @[JSON::Field(key: "next")]
+  property union_list_next : UnionList
+end
+
+alias UnionList = Float64 | UnionListClass
diff --git a/head/schema-crystal/test/inputs/schema/union.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/union.schema/default/TopLevel.cr
new file mode 100644
index 0000000..c80d934
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/union.schema/default/TopLevel.cr
@@ -0,0 +1,13 @@
+require "json"
+
+alias TopLevel = Array(TopLevelElement)
+
+class TopLevelElement
+  include JSON::Serializable
+
+  property one : Int32?
+
+  property two : Bool
+
+  property three : Float64?
+end
diff --git a/head/schema-crystal/test/inputs/schema/uuid.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/uuid.schema/default/TopLevel.cr
new file mode 100644
index 0000000..d3af4c0
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/uuid.schema/default/TopLevel.cr
@@ -0,0 +1,20 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  @[JSON::Field(key: "arrNullable")]
+  property arr_nullable : Array(String?)?
+
+  @[JSON::Field(key: "arrOne")]
+  property arr_one : Array(String)?
+
+  property nullable : String?
+
+  property one : String
+
+  property optional : String?
+
+  @[JSON::Field(key: "unionWithEnum")]
+  property union_with_enum : String
+end
diff --git a/head/schema-crystal/test/inputs/schema/vega-lite.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/vega-lite.schema/default/TopLevel.cr
new file mode 100644
index 0000000..745c94b
--- /dev/null
+++ b/head/schema-crystal/test/inputs/schema/vega-lite.schema/default/TopLevel.cr
@@ -0,0 +1,5057 @@
+require "json"
+
+class TopLevel
+  include JSON::Serializable
+
+  # URL to [JSON schema](http://json-schema.org/) for a Vega-Lite specification. Unless you
+  # have a reason to change this, use `https://vega.github.io/schema/vega-lite/v2.json`.
+  # Setting the `$schema` property allows automatic validation and autocomplete in editors
+  # that support JSON schema.
+  @[JSON::Field(key: "$schema")]
+  property schema : String?
+
+  # Sets how the visualization size should be determined. If a string, should be one of
+  # `"pad"`, `"fit"` or `"none"`.
+  # Object values can additionally specify parameters for content sizing and automatic
+  # resizing.
+  # `"fit"` is only supported for single and layered views that don't use `rangeStep`.
+  #
+  # __Default value__: `pad`
+  property autosize : Autosize?
+
+  # CSS color property to use as the background of visualization.
+  #
+  # __Default value:__ none (transparent)
+  property background : String?
+
+  # Vega-Lite configuration object.  This property can only be defined at the top-level of a
+  # specification.
+  property config : Config?
+
+  # An object describing the data source
+  property data : Data?
+
+  # Description of this mark for commenting purpose.
+  property description : String?
+
+  # A key-value mapping between encoding channels and definition of fields.
+  property encoding : EncodingWithFacet?
+
+  # The height of a visualization.
+  #
+  # __Default value:__
+  # - If a view's [`autosize`](size.html#autosize) type is `"fit"` or its y-channel has a
+  # [continuous scale](scale.html#continuous), the height will be the value of
+  # [`config.view.height`](spec.html#config).
+  # - For y-axis with a band or point scale: if [`rangeStep`](scale.html#band) is a numeric
+  # value or unspecified, the height is [determined by the range step, paddings, and the
+  # cardinality of the field mapped to y-channel](scale.html#band). Otherwise, if the
+  # `rangeStep` is `null`, the height will be the value of
+  # [`config.view.height`](spec.html#config).
+  # - If no field is mapped to `y` channel, the `height` will be the value of `rangeStep`.
+  #
+  # __Note__: For plots with [`row` and `column` channels](encoding.html#facet), this
+  # represents the height of a single view.
+  #
+  # __See also:__ The documentation for [width and height](size.html) contains more examples.
+  property height : Float64?
+
+  # A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
+  # `"line"`,
+  # * `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark definition
+  # object](mark.html#mark-def).
+  property mark : AnyMark?
+
+  # Name of the visualization for later reference.
+  property name : String?
+
+  # The default visualization padding, in pixels, from the edge of the visualization canvas
+  # to the data rectangle.  If a number, specifies padding for all sides.
+  # If an object, the value should have the format `{"left": 5, "top": 5, "right": 5,
+  # "bottom": 5}` to specify padding for each side of the visualization.
+  #
+  # __Default value__: `5`
+  property padding : Padding?
+
+  # An object defining properties of geographic projection.
+  #
+  # Works with `"geoshape"` marks and `"point"` or `"line"` marks that have a channel (one or
+  # more of `"X"`, `"X2"`, `"Y"`, `"Y2"`) with type `"latitude"`, or `"longitude"`.
+  property projection : Projection?
+
+  # A key-value mapping between selection names and definitions.
+  property selection : Hash(String, SelectionDef)?
+
+  # Title for the plot.
+  property title : Title?
+
+  # An array of data transformations such as filter and new field calculation.
+  property transform : Array(Transform)?
+
+  # The width of a visualization.
+  #
+  # __Default value:__ This will be determined by the following rules:
+  #
+  # - If a view's [`autosize`](size.html#autosize) type is `"fit"` or its x-channel has a
+  # [continuous scale](scale.html#continuous), the width will be the value of
+  # [`config.view.width`](spec.html#config).
+  # - For x-axis with a band or point scale: if [`rangeStep`](scale.html#band) is a numeric
+  # value or unspecified, the width is [determined by the range step, paddings, and the
+  # cardinality of the field mapped to x-channel](scale.html#band).   Otherwise, if the
+  # `rangeStep` is `null`, the width will be the value of
+  # [`config.view.width`](spec.html#config).
+  # - If no field is mapped to `x` channel, the `width` will be the value of
+  # [`config.scale.textXRangeStep`](size.html#default-width-and-height) for `text` mark and
+  # the value of `rangeStep` for other marks.
+  #
+  # __Note:__ For plots with [`row` and `column` channels](encoding.html#facet), this
+  # represents the width of a single view.
+  #
+  # __See also:__ The documentation for [width and height](size.html) contains more examples.
+  property width : Float64?
+
+  # Layer or single view specifications to be layered.
+  #
+  # __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
+  # layering facet specifications is not allowed.
+  property layer : Array(LayerSpec)?
+
+  # Scale, axis, and legend resolutions for layers.
+  #
+  # Scale, axis, and legend resolutions for facets.
+  #
+  # Scale and legend resolutions for repeated charts.
+  #
+  # Scale, axis, and legend resolutions for vertically concatenated charts.
+  #
+  # Scale, axis, and legend resolutions for horizontally concatenated charts.
+  property resolve : Resolve?
+
+  # An object that describes mappings between `row` and `column` channels and their field
+  # definitions.
+  property facet : FacetMapping?
+
+  # A specification of the view that gets faceted.
+  property spec : SpecElement?
+
+  # An object that describes what fields should be repeated into views that are laid out as a
+  # `row` or `column`.
+  property repeat : Repeat?
+
+  # A list of views that should be concatenated and put into a column.
+  property vconcat : Array(SpecElement)?
+
+  # A list of views that should be concatenated and put into a row.
+  property hconcat : Array(SpecElement)?
+end
+
+class AutoSizeParams
+  include JSON::Serializable
+
+  # Determines how size calculation should be performed, one of `"content"` or `"padding"`.
+  # The default setting (`"content"`) interprets the width and height settings as the data
+  # rectangle (plotting) dimensions, to which padding is then added. In contrast, the
+  # `"padding"` setting includes the padding within the view size calculations, such that the
+  # width and height settings indicate the **total** intended size of the view.
+  #
+  # __Default value__: `"content"`
+  property contains : String?
+
+  # A boolean flag indicating if autosize layout should be re-calculated on every view
+  # update.
+  #
+  # __Default value__: `false`
+  property resize : Bool?
+
+  # The sizing format type. One of `"pad"`, `"fit"` or `"none"`. See the [autosize
+  # type](https://vega.github.io/vega-lite/docs/size.html#autosize) documentation for
+  # descriptions of each.
+  #
+  # __Default value__: `"pad"`
+  @[JSON::Field(key: "type")]
+  property auto_size_params_type : String?
+end
+
+# Vega-Lite configuration object.  This property can only be defined at the top-level of a
+# specification.
+class Config
+  include JSON::Serializable
+
+  # Area-Specific Config
+  property area : MarkConfig?
+
+  # Sets how the visualization size should be determined. If a string, should be one of
+  # `"pad"`, `"fit"` or `"none"`.
+  # Object values can additionally specify parameters for content sizing and automatic
+  # resizing.
+  # `"fit"` is only supported for single and layered views that don't use `rangeStep`.
+  #
+  # __Default value__: `pad`
+  property autosize : Autosize?
+
+  # Axis configuration, which determines default properties for all `x` and `y`
+  # [axes](axis.html). For a full list of axis configuration options, please see the
+  # [corresponding section of the axis documentation](axis.html#config).
+  property axis : AxisConfig?
+
+  # Specific axis config for axes with "band" scales.
+  @[JSON::Field(key: "axisBand")]
+  property axis_band : VgAxisConfig?
+
+  # Specific axis config for x-axis along the bottom edge of the chart.
+  @[JSON::Field(key: "axisBottom")]
+  property axis_bottom : VgAxisConfig?
+
+  # Specific axis config for y-axis along the left edge of the chart.
+  @[JSON::Field(key: "axisLeft")]
+  property axis_left : VgAxisConfig?
+
+  # Specific axis config for y-axis along the right edge of the chart.
+  @[JSON::Field(key: "axisRight")]
+  property axis_right : VgAxisConfig?
+
+  # Specific axis config for x-axis along the top edge of the chart.
+  @[JSON::Field(key: "axisTop")]
+  property axis_top : VgAxisConfig?
+
+  # X-axis specific config.
+  @[JSON::Field(key: "axisX")]
+  property axis_x : VgAxisConfig?
+
+  # Y-axis specific config.
+  @[JSON::Field(key: "axisY")]
+  property axis_y : VgAxisConfig?
+
+  # CSS color property to use as the background of visualization.
+  #
+  # __Default value:__ none (transparent)
+  property background : String?
+
+  # Bar-Specific Config
+  property bar : BarConfig?
+
+  # Circle-Specific Config
+  property circle : MarkConfig?
+
+  # Default axis and legend title for count fields.
+  #
+  # __Default value:__ `'Number of Records'`.
+  @[JSON::Field(key: "countTitle")]
+  property count_title : String?
+
+  # Defines how Vega-Lite generates title for fields.  There are three possible styles:
+  #
+  # - `"verbal"` (Default) - displays function in a verbal style (e.g., "Sum of field",
+  # "Year-month of date", "field (binned)").
+  # - `"function"` - displays function using parentheses and capitalized texts (e.g.,
+  # "SUM(field)", "YEARMONTH(date)", "BIN(field)").
+  # - `"plain"` - displays only the field name without functions (e.g., "field", "date",
+  # "field").
+  @[JSON::Field(key: "fieldTitle")]
+  property field_title : String?
+
+  # Geoshape-Specific Config
+  property geoshape : MarkConfig?
+
+  # Defines how Vega-Lite should handle invalid values (`null` and `NaN`).
+  # - If set to `"filter"` (default), all data items with null values are filtered.
+  # - If `null`, all data items are included. In this case, invalid values will be
+  # interpreted as zeroes.
+  @[JSON::Field(key: "invalidValues")]
+  property invalid_values : String?
+
+  # Legend configuration, which determines default properties for all [legends](legend.html).
+  # For a full list of legend configuration options, please see the [corresponding section of
+  # in the legend documentation](legend.html#config).
+  property legend : LegendConfig?
+
+  # Line-Specific Config
+  property line : MarkConfig?
+
+  # Mark Config
+  property mark : MarkConfig?
+
+  # D3 Number format for axis labels and text tables. For example "s" for SI units. Use [D3's
+  # number format pattern](https://github.com/d3/d3-format#locale_format).
+  @[JSON::Field(key: "numberFormat")]
+  property number_format : String?
+
+  # The default visualization padding, in pixels, from the edge of the visualization canvas
+  # to the data rectangle.  If a number, specifies padding for all sides.
+  # If an object, the value should have the format `{"left": 5, "top": 5, "right": 5,
+  # "bottom": 5}` to specify padding for each side of the visualization.
+  #
+  # __Default value__: `5`
+  property padding : Padding?
+
+  # Point-Specific Config
+  property point : MarkConfig?
+
+  # Projection configuration, which determines default properties for all
+  # [projections](projection.html). For a full list of projection configuration options,
+  # please see the [corresponding section of the projection
+  # documentation](projection.html#config).
+  property projection : ProjectionConfig?
+
+  # An object hash that defines default range arrays or schemes for using with scales.
+  # For a full list of scale range configuration options, please see the [corresponding
+  # section of the scale documentation](scale.html#config).
+  property range : Hash(String, RangeConfigValue)?
+
+  # Rect-Specific Config
+  property rect : MarkConfig?
+
+  # Rule-Specific Config
+  property rule : MarkConfig?
+
+  # Scale configuration determines default properties for all [scales](scale.html). For a
+  # full list of scale configuration options, please see the [corresponding section of the
+  # scale documentation](scale.html#config).
+  property scale : ScaleConfig?
+
+  # An object hash for defining default properties for each type of selections.
+  property selection : SelectionConfig?
+
+  # Square-Specific Config
+  property square : MarkConfig?
+
+  # Default stack offset for stackable mark.
+  property stack : String?
+
+  # An object hash that defines key-value mappings to determine default properties for marks
+  # with a given [style](mark.html#mark-def).  The keys represent styles names; the value are
+  # valid [mark configuration objects](mark.html#config).
+  property style : Hash(String, VgMarkConfig)?
+
+  # Text-Specific Config
+  property text : TextConfig?
+
+  # Tick-Specific Config
+  property tick : TickConfig?
+
+  # Default datetime format for axis and legend labels. The format can be set directly on
+  # each axis and legend. Use [D3's time format
+  # pattern](https://github.com/d3/d3-time-format#locale_format).
+  #
+  # __Default value:__ `'%b %d, %Y'`.
+  @[JSON::Field(key: "timeFormat")]
+  property time_format : String?
+
+  # Title configuration, which determines default properties for all [titles](title.html).
+  # For a full list of title configuration options, please see the [corresponding section of
+  # the title documentation](title.html#config).
+  property title : VgTitleConfig?
+
+  # Default properties for [single view plots](spec.html#single).
+  property view : ViewConfig?
+end
+
+# Area-Specific Config
+#
+# Circle-Specific Config
+#
+# Geoshape-Specific Config
+#
+# Line-Specific Config
+#
+# Mark Config
+#
+# Point-Specific Config
+#
+# Rect-Specific Config
+#
+# Rule-Specific Config
+#
+# Square-Specific Config
+class MarkConfig
+  include JSON::Serializable
+
+  # The horizontal alignment of the text. One of `"left"`, `"right"`, `"center"`.
+  property align : String?
+
+  # The rotation angle of the text, in degrees.
+  property angle : Float64?
+
+  # The vertical alignment of the text. One of `"top"`, `"middle"`, `"bottom"`.
+  #
+  # __Default value:__ `"middle"`
+  property baseline : String?
+
+  # Default color.  Note that `fill` and `stroke` have higher precedence than `color` and
+  # will override `color`.
+  #
+  # __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property color : String?
+
+  # The mouse cursor used over the mark. Any valid [CSS cursor
+  # type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
+  property cursor : String?
+
+  # The horizontal offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dx : Float64?
+
+  # The vertical offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dy : Float64?
+
+  # Default Fill Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property fill : String?
+
+  # Whether the mark's color should be used as fill color instead of stroke color.
+  #
+  # __Default value:__ `true` for all marks except `point` and `false` for `point`.
+  #
+  # __Applicable for:__ `bar`, `point`, `circle`, `square`, and `area` marks.
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property filled : Bool?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The typeface to set the text in (e.g., `"Helvetica Neue"`).
+  property font : String?
+
+  # The font size, in pixels.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # The font style (e.g., `"italic"`).
+  @[JSON::Field(key: "fontStyle")]
+  property font_style : String?
+
+  # The font weight (e.g., `"bold"`).
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # A URL to load upon mouse click. If defined, the mark acts as a hyperlink.
+  property href : String?
+
+  # The line interpolation method to use for line and area marks. One of the following:
+  # - `"linear"`: piecewise linear segments, as in a polyline.
+  # - `"linear-closed"`: close the linear segments to form a polygon.
+  # - `"step"`: alternate between horizontal and vertical segments, as in a step function.
+  # - `"step-before"`: alternate between vertical and horizontal segments, as in a step
+  # function.
+  # - `"step-after"`: alternate between horizontal and vertical segments, as in a step
+  # function.
+  # - `"basis"`: a B-spline, with control point duplication on the ends.
+  # - `"basis-open"`: an open B-spline; may not intersect the start or end.
+  # - `"basis-closed"`: a closed B-spline, as in a loop.
+  # - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
+  # - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
+  # will intersect other control points.
+  # - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
+  # - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
+  # spline.
+  # - `"monotone"`: cubic interpolation that preserves monotonicity in y.
+  property interpolate : String?
+
+  # The maximum length of the text mark in pixels (default 0, indicating no limit). The text
+  # value will be automatically truncated if the rendered size exceeds the limit.
+  property limit : Float64?
+
+  # The overall opacity (value between [0,1]).
+  #
+  # __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
+  # `square` marks or layered `bar` charts and `1` otherwise.
+  property opacity : Float64?
+
+  # The orientation of a non-stacked bar, tick, area, and line charts.
+  # The value is either horizontal (default) or vertical.
+  # - For bar, rule and tick, this determines whether the size of the bar and tick
+  # should be applied to x or y dimension.
+  # - For area, this property determines the orient property of the Vega output.
+  # - For line, this property determines the sort order of the points in the line
+  # if `config.sortLineBy` is not specified.
+  # For stacked charts, this is always determined by the orientation of the stack;
+  # therefore explicitly specified value will be ignored.
+  property orient : String?
+
+  # Polar coordinate radial offset, in pixels, of the text label from the origin determined
+  # by the `x` and `y` properties.
+  property radius : Float64?
+
+  # The default symbol shape to use. One of: `"circle"` (default), `"square"`, `"cross"`,
+  # `"diamond"`, `"triangle-up"`, or `"triangle-down"`, or a custom SVG path.
+  #
+  # __Default value:__ `"circle"`
+  property shape : String?
+
+  # The pixel area each the point/circle/square.
+  # For example: in the case of circles, the radius is determined in part by the square root
+  # of the size value.
+  #
+  # __Default value:__ `30`
+  property size : Float64?
+
+  # Default Stroke Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # Depending on the interpolation type, sets the tension parameter (for line and area marks).
+  property tension : Float64?
+
+  # Placeholder text if the `text` channel is not specified
+  property text : String?
+
+  # Polar coordinate angle, in radians, of the text label from the origin determined by the
+  # `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark
+  # `startAngle` and `endAngle` properties: angles are measured in radians, with `0`
+  # indicating "north".
+  property theta : Float64?
+end
+
+# Axis configuration, which determines default properties for all `x` and `y`
+# [axes](axis.html). For a full list of axis configuration options, please see the
+# [corresponding section of the axis documentation](axis.html#config).
+class AxisConfig
+  include JSON::Serializable
+
+  # An interpolation fraction indicating where, for `band` scales, axis ticks should be
+  # positioned. A value of `0` places ticks at the left edge of their bands. A value of `0.5`
+  # places ticks in the middle of their bands.
+  @[JSON::Field(key: "bandPosition")]
+  property band_position : Float64?
+
+  # A boolean flag indicating if the domain (the axis baseline) should be included as part of
+  # the axis.
+  #
+  # __Default value:__ `true`
+  property domain : Bool?
+
+  # Color of axis domain line.
+  #
+  # __Default value:__  (none, using Vega default).
+  @[JSON::Field(key: "domainColor")]
+  property domain_color : String?
+
+  # Stroke width of axis domain line
+  #
+  # __Default value:__  (none, using Vega default).
+  @[JSON::Field(key: "domainWidth")]
+  property domain_width : Float64?
+
+  # A boolean flag indicating if grid lines should be included as part of the axis
+  #
+  # __Default value:__ `true` for [continuous scales](scale.html#continuous) that are not
+  # binned; otherwise, `false`.
+  property grid : Bool?
+
+  # Color of gridlines.
+  @[JSON::Field(key: "gridColor")]
+  property grid_color : String?
+
+  # The offset (in pixels) into which to begin drawing with the grid dash array.
+  @[JSON::Field(key: "gridDash")]
+  property grid_dash : Array(Float64)?
+
+  # The stroke opacity of grid (value between [0,1])
+  #
+  # __Default value:__ (`1` by default)
+  @[JSON::Field(key: "gridOpacity")]
+  property grid_opacity : Float64?
+
+  # The grid width, in pixels.
+  @[JSON::Field(key: "gridWidth")]
+  property grid_width : Float64?
+
+  # The rotation angle of the axis labels.
+  #
+  # __Default value:__ `-90` for nominal and ordinal fields; `0` otherwise.
+  @[JSON::Field(key: "labelAngle")]
+  property label_angle : Float64?
+
+  # Indicates if labels should be hidden if they exceed the axis range. If `false `(the
+  # default) no bounds overlap analysis is performed. If `true`, labels will be hidden if
+  # they exceed the axis range by more than 1 pixel. If this property is a number, it
+  # specifies the pixel tolerance: the maximum amount by which a label bounding box may
+  # exceed the axis range.
+  #
+  # __Default value:__ `false`.
+  @[JSON::Field(key: "labelBound")]
+  property label_bound : Label?
+
+  # The color of the tick label, can be in hex color code or regular color name.
+  @[JSON::Field(key: "labelColor")]
+  property label_color : String?
+
+  # Indicates if the first and last axis labels should be aligned flush with the scale range.
+  # Flush alignment for a horizontal axis will left-align the first label and right-align the
+  # last label. For vertical axes, bottom and top text baselines are applied instead. If this
+  # property is a number, it also indicates the number of pixels by which to offset the first
+  # and last labels; for example, a value of 2 will flush-align the first and last labels and
+  # also push them 2 pixels outward from the center of the axis. The additional adjustment
+  # can sometimes help the labels better visually group with corresponding axis ticks.
+  #
+  # __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
+  @[JSON::Field(key: "labelFlush")]
+  property label_flush : Label?
+
+  # The font of the tick label.
+  @[JSON::Field(key: "labelFont")]
+  property label_font : String?
+
+  # The font size of the label, in pixels.
+  @[JSON::Field(key: "labelFontSize")]
+  property label_font_size : Float64?
+
+  # Maximum allowed pixel width of axis tick labels.
+  @[JSON::Field(key: "labelLimit")]
+  property label_limit : Float64?
+
+  # The strategy to use for resolving overlap of axis labels. If `false` (the default), no
+  # overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
+  # every other label is used (this works well for standard linear axes). If set to
+  # `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
+  # with the last visible label (this often works better for log-scaled axes).
+  #
+  # __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
+  # scales; otherwise `false`.
+  @[JSON::Field(key: "labelOverlap")]
+  property label_overlap : LabelOverlapUnion?
+
+  # The padding, in pixels, between axis and text labels.
+  @[JSON::Field(key: "labelPadding")]
+  property label_padding : Float64?
+
+  # A boolean flag indicating if labels should be included as part of the axis.
+  #
+  # __Default value:__  `true`.
+  property labels : Bool?
+
+  # The maximum extent in pixels that axis ticks and labels should use. This determines a
+  # maximum offset value for axis titles.
+  #
+  # __Default value:__ `undefined`.
+  @[JSON::Field(key: "maxExtent")]
+  property max_extent : Float64?
+
+  # The minimum extent in pixels that axis ticks and labels should use. This determines a
+  # minimum offset value for axis titles.
+  #
+  # __Default value:__ `30` for y-axis; `undefined` for x-axis.
+  @[JSON::Field(key: "minExtent")]
+  property min_extent : Float64?
+
+  # Whether month names and weekday names should be abbreviated.
+  #
+  # __Default value:__  `false`
+  @[JSON::Field(key: "shortTimeLabels")]
+  property short_time_labels : Bool?
+
+  # The color of the axis's tick.
+  @[JSON::Field(key: "tickColor")]
+  property tick_color : String?
+
+  # Boolean flag indicating if pixel position values should be rounded to the nearest integer.
+  @[JSON::Field(key: "tickRound")]
+  property tick_round : Bool?
+
+  # Boolean value that determines whether the axis should include ticks.
+  property ticks : Bool?
+
+  # The size in pixels of axis ticks.
+  @[JSON::Field(key: "tickSize")]
+  property tick_size : Float64?
+
+  # The width, in pixels, of ticks.
+  @[JSON::Field(key: "tickWidth")]
+  property tick_width : Float64?
+
+  # Horizontal text alignment of axis titles.
+  @[JSON::Field(key: "titleAlign")]
+  property title_align : String?
+
+  # Angle in degrees of axis titles.
+  @[JSON::Field(key: "titleAngle")]
+  property title_angle : Float64?
+
+  # Vertical text baseline for axis titles.
+  @[JSON::Field(key: "titleBaseline")]
+  property title_baseline : String?
+
+  # Color of the title, can be in hex color code or regular color name.
+  @[JSON::Field(key: "titleColor")]
+  property title_color : String?
+
+  # Font of the title. (e.g., `"Helvetica Neue"`).
+  @[JSON::Field(key: "titleFont")]
+  property title_font : String?
+
+  # Font size of the title.
+  @[JSON::Field(key: "titleFontSize")]
+  property title_font_size : Float64?
+
+  # Font weight of the title. (e.g., `"bold"`).
+  @[JSON::Field(key: "titleFontWeight")]
+  property title_font_weight : TitleFontWeightUnion?
+
+  # Maximum allowed pixel width of axis titles.
+  @[JSON::Field(key: "titleLimit")]
+  property title_limit : Float64?
+
+  # Max length for axis title if the title is automatically generated from the field's
+  # description.
+  @[JSON::Field(key: "titleMaxLength")]
+  property title_max_length : Float64?
+
+  # The padding, in pixels, between title and axis.
+  @[JSON::Field(key: "titlePadding")]
+  property title_padding : Float64?
+
+  # X-coordinate of the axis title relative to the axis group.
+  @[JSON::Field(key: "titleX")]
+  property title_x : Float64?
+
+  # Y-coordinate of the axis title relative to the axis group.
+  @[JSON::Field(key: "titleY")]
+  property title_y : Float64?
+end
+
+# Specific axis config for axes with "band" scales.
+#
+# Specific axis config for x-axis along the bottom edge of the chart.
+#
+# Specific axis config for y-axis along the left edge of the chart.
+#
+# Specific axis config for y-axis along the right edge of the chart.
+#
+# Specific axis config for x-axis along the top edge of the chart.
+#
+# X-axis specific config.
+#
+# Y-axis specific config.
+class VgAxisConfig
+  include JSON::Serializable
+
+  # An interpolation fraction indicating where, for `band` scales, axis ticks should be
+  # positioned. A value of `0` places ticks at the left edge of their bands. A value of `0.5`
+  # places ticks in the middle of their bands.
+  @[JSON::Field(key: "bandPosition")]
+  property band_position : Float64?
+
+  # A boolean flag indicating if the domain (the axis baseline) should be included as part of
+  # the axis.
+  #
+  # __Default value:__ `true`
+  property domain : Bool?
+
+  # Color of axis domain line.
+  #
+  # __Default value:__  (none, using Vega default).
+  @[JSON::Field(key: "domainColor")]
+  property domain_color : String?
+
+  # Stroke width of axis domain line
+  #
+  # __Default value:__  (none, using Vega default).
+  @[JSON::Field(key: "domainWidth")]
+  property domain_width : Float64?
+
+  # A boolean flag indicating if grid lines should be included as part of the axis
+  #
+  # __Default value:__ `true` for [continuous scales](scale.html#continuous) that are not
+  # binned; otherwise, `false`.
+  property grid : Bool?
+
+  # Color of gridlines.
+  @[JSON::Field(key: "gridColor")]
+  property grid_color : String?
+
+  # The offset (in pixels) into which to begin drawing with the grid dash array.
+  @[JSON::Field(key: "gridDash")]
+  property grid_dash : Array(Float64)?
+
+  # The stroke opacity of grid (value between [0,1])
+  #
+  # __Default value:__ (`1` by default)
+  @[JSON::Field(key: "gridOpacity")]
+  property grid_opacity : Float64?
+
+  # The grid width, in pixels.
+  @[JSON::Field(key: "gridWidth")]
+  property grid_width : Float64?
+
+  # The rotation angle of the axis labels.
+  #
+  # __Default value:__ `-90` for nominal and ordinal fields; `0` otherwise.
+  @[JSON::Field(key: "labelAngle")]
+  property label_angle : Float64?
+
+  # Indicates if labels should be hidden if they exceed the axis range. If `false `(the
+  # default) no bounds overlap analysis is performed. If `true`, labels will be hidden if
+  # they exceed the axis range by more than 1 pixel. If this property is a number, it
+  # specifies the pixel tolerance: the maximum amount by which a label bounding box may
+  # exceed the axis range.
+  #
+  # __Default value:__ `false`.
+  @[JSON::Field(key: "labelBound")]
+  property label_bound : Label?
+
+  # The color of the tick label, can be in hex color code or regular color name.
+  @[JSON::Field(key: "labelColor")]
+  property label_color : String?
+
+  # Indicates if the first and last axis labels should be aligned flush with the scale range.
+  # Flush alignment for a horizontal axis will left-align the first label and right-align the
+  # last label. For vertical axes, bottom and top text baselines are applied instead. If this
+  # property is a number, it also indicates the number of pixels by which to offset the first
+  # and last labels; for example, a value of 2 will flush-align the first and last labels and
+  # also push them 2 pixels outward from the center of the axis. The additional adjustment
+  # can sometimes help the labels better visually group with corresponding axis ticks.
+  #
+  # __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
+  @[JSON::Field(key: "labelFlush")]
+  property label_flush : Label?
+
+  # The font of the tick label.
+  @[JSON::Field(key: "labelFont")]
+  property label_font : String?
+
+  # The font size of the label, in pixels.
+  @[JSON::Field(key: "labelFontSize")]
+  property label_font_size : Float64?
+
+  # Maximum allowed pixel width of axis tick labels.
+  @[JSON::Field(key: "labelLimit")]
+  property label_limit : Float64?
+
+  # The strategy to use for resolving overlap of axis labels. If `false` (the default), no
+  # overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
+  # every other label is used (this works well for standard linear axes). If set to
+  # `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
+  # with the last visible label (this often works better for log-scaled axes).
+  #
+  # __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
+  # scales; otherwise `false`.
+  @[JSON::Field(key: "labelOverlap")]
+  property label_overlap : LabelOverlapUnion?
+
+  # The padding, in pixels, between axis and text labels.
+  @[JSON::Field(key: "labelPadding")]
+  property label_padding : Float64?
+
+  # A boolean flag indicating if labels should be included as part of the axis.
+  #
+  # __Default value:__  `true`.
+  property labels : Bool?
+
+  # The maximum extent in pixels that axis ticks and labels should use. This determines a
+  # maximum offset value for axis titles.
+  #
+  # __Default value:__ `undefined`.
+  @[JSON::Field(key: "maxExtent")]
+  property max_extent : Float64?
+
+  # The minimum extent in pixels that axis ticks and labels should use. This determines a
+  # minimum offset value for axis titles.
+  #
+  # __Default value:__ `30` for y-axis; `undefined` for x-axis.
+  @[JSON::Field(key: "minExtent")]
+  property min_extent : Float64?
+
+  # The color of the axis's tick.
+  @[JSON::Field(key: "tickColor")]
+  property tick_color : String?
+
+  # Boolean flag indicating if pixel position values should be rounded to the nearest integer.
+  @[JSON::Field(key: "tickRound")]
+  property tick_round : Bool?
+
+  # Boolean value that determines whether the axis should include ticks.
+  property ticks : Bool?
+
+  # The size in pixels of axis ticks.
+  @[JSON::Field(key: "tickSize")]
+  property tick_size : Float64?
+
+  # The width, in pixels, of ticks.
+  @[JSON::Field(key: "tickWidth")]
+  property tick_width : Float64?
+
+  # Horizontal text alignment of axis titles.
+  @[JSON::Field(key: "titleAlign")]
+  property title_align : String?
+
+  # Angle in degrees of axis titles.
+  @[JSON::Field(key: "titleAngle")]
+  property title_angle : Float64?
+
+  # Vertical text baseline for axis titles.
+  @[JSON::Field(key: "titleBaseline")]
+  property title_baseline : String?
+
+  # Color of the title, can be in hex color code or regular color name.
+  @[JSON::Field(key: "titleColor")]
+  property title_color : String?
+
+  # Font of the title. (e.g., `"Helvetica Neue"`).
+  @[JSON::Field(key: "titleFont")]
+  property title_font : String?
+
+  # Font size of the title.
+  @[JSON::Field(key: "titleFontSize")]
+  property title_font_size : Float64?
+
+  # Font weight of the title. (e.g., `"bold"`).
+  @[JSON::Field(key: "titleFontWeight")]
+  property title_font_weight : TitleFontWeightUnion?
+
+  # Maximum allowed pixel width of axis titles.
+  @[JSON::Field(key: "titleLimit")]
+  property title_limit : Float64?
+
+  # Max length for axis title if the title is automatically generated from the field's
+  # description.
+  @[JSON::Field(key: "titleMaxLength")]
+  property title_max_length : Float64?
+
+  # The padding, in pixels, between title and axis.
+  @[JSON::Field(key: "titlePadding")]
+  property title_padding : Float64?
+
+  # X-coordinate of the axis title relative to the axis group.
+  @[JSON::Field(key: "titleX")]
+  property title_x : Float64?
+
+  # Y-coordinate of the axis title relative to the axis group.
+  @[JSON::Field(key: "titleY")]
+  property title_y : Float64?
+end
+
+# Bar-Specific Config
+class BarConfig
+  include JSON::Serializable
+
+  # The horizontal alignment of the text. One of `"left"`, `"right"`, `"center"`.
+  property align : String?
+
+  # The rotation angle of the text, in degrees.
+  property angle : Float64?
+
+  # The vertical alignment of the text. One of `"top"`, `"middle"`, `"bottom"`.
+  #
+  # __Default value:__ `"middle"`
+  property baseline : String?
+
+  # Offset between bar for binned field.  Ideal value for this is either 0 (Preferred by
+  # statisticians) or 1 (Vega-Lite Default, D3 example style).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "binSpacing")]
+  property bin_spacing : Float64?
+
+  # Default color.  Note that `fill` and `stroke` have higher precedence than `color` and
+  # will override `color`.
+  #
+  # __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property color : String?
+
+  # The default size of the bars on continuous scales.
+  #
+  # __Default value:__ `5`
+  @[JSON::Field(key: "continuousBandSize")]
+  property continuous_band_size : Float64?
+
+  # The mouse cursor used over the mark. Any valid [CSS cursor
+  # type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
+  property cursor : String?
+
+  # The size of the bars.  If unspecified, the default size is  `bandSize-1`,
+  # which provides 1 pixel offset between bars.
+  @[JSON::Field(key: "discreteBandSize")]
+  property discrete_band_size : Float64?
+
+  # The horizontal offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dx : Float64?
+
+  # The vertical offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dy : Float64?
+
+  # Default Fill Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property fill : String?
+
+  # Whether the mark's color should be used as fill color instead of stroke color.
+  #
+  # __Default value:__ `true` for all marks except `point` and `false` for `point`.
+  #
+  # __Applicable for:__ `bar`, `point`, `circle`, `square`, and `area` marks.
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property filled : Bool?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The typeface to set the text in (e.g., `"Helvetica Neue"`).
+  property font : String?
+
+  # The font size, in pixels.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # The font style (e.g., `"italic"`).
+  @[JSON::Field(key: "fontStyle")]
+  property font_style : String?
+
+  # The font weight (e.g., `"bold"`).
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # A URL to load upon mouse click. If defined, the mark acts as a hyperlink.
+  property href : String?
+
+  # The line interpolation method to use for line and area marks. One of the following:
+  # - `"linear"`: piecewise linear segments, as in a polyline.
+  # - `"linear-closed"`: close the linear segments to form a polygon.
+  # - `"step"`: alternate between horizontal and vertical segments, as in a step function.
+  # - `"step-before"`: alternate between vertical and horizontal segments, as in a step
+  # function.
+  # - `"step-after"`: alternate between horizontal and vertical segments, as in a step
+  # function.
+  # - `"basis"`: a B-spline, with control point duplication on the ends.
+  # - `"basis-open"`: an open B-spline; may not intersect the start or end.
+  # - `"basis-closed"`: a closed B-spline, as in a loop.
+  # - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
+  # - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
+  # will intersect other control points.
+  # - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
+  # - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
+  # spline.
+  # - `"monotone"`: cubic interpolation that preserves monotonicity in y.
+  property interpolate : String?
+
+  # The maximum length of the text mark in pixels (default 0, indicating no limit). The text
+  # value will be automatically truncated if the rendered size exceeds the limit.
+  property limit : Float64?
+
+  # The overall opacity (value between [0,1]).
+  #
+  # __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
+  # `square` marks or layered `bar` charts and `1` otherwise.
+  property opacity : Float64?
+
+  # The orientation of a non-stacked bar, tick, area, and line charts.
+  # The value is either horizontal (default) or vertical.
+  # - For bar, rule and tick, this determines whether the size of the bar and tick
+  # should be applied to x or y dimension.
+  # - For area, this property determines the orient property of the Vega output.
+  # - For line, this property determines the sort order of the points in the line
+  # if `config.sortLineBy` is not specified.
+  # For stacked charts, this is always determined by the orientation of the stack;
+  # therefore explicitly specified value will be ignored.
+  property orient : String?
+
+  # Polar coordinate radial offset, in pixels, of the text label from the origin determined
+  # by the `x` and `y` properties.
+  property radius : Float64?
+
+  # The default symbol shape to use. One of: `"circle"` (default), `"square"`, `"cross"`,
+  # `"diamond"`, `"triangle-up"`, or `"triangle-down"`, or a custom SVG path.
+  #
+  # __Default value:__ `"circle"`
+  property shape : String?
+
+  # The pixel area each the point/circle/square.
+  # For example: in the case of circles, the radius is determined in part by the square root
+  # of the size value.
+  #
+  # __Default value:__ `30`
+  property size : Float64?
+
+  # Default Stroke Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # Depending on the interpolation type, sets the tension parameter (for line and area marks).
+  property tension : Float64?
+
+  # Placeholder text if the `text` channel is not specified
+  property text : String?
+
+  # Polar coordinate angle, in radians, of the text label from the origin determined by the
+  # `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark
+  # `startAngle` and `endAngle` properties: angles are measured in radians, with `0`
+  # indicating "north".
+  property theta : Float64?
+end
+
+# Legend configuration, which determines default properties for all [legends](legend.html).
+# For a full list of legend configuration options, please see the [corresponding section of
+# in the legend documentation](legend.html#config).
+class LegendConfig
+  include JSON::Serializable
+
+  # Corner radius for the full legend.
+  @[JSON::Field(key: "cornerRadius")]
+  property corner_radius : Float64?
+
+  # Padding (in pixels) between legend entries in a symbol legend.
+  @[JSON::Field(key: "entryPadding")]
+  property entry_padding : Float64?
+
+  # Background fill color for the full legend.
+  @[JSON::Field(key: "fillColor")]
+  property fill_color : String?
+
+  # The height of the gradient, in pixels.
+  @[JSON::Field(key: "gradientHeight")]
+  property gradient_height : Float64?
+
+  # Text baseline for color ramp gradient labels.
+  @[JSON::Field(key: "gradientLabelBaseline")]
+  property gradient_label_baseline : String?
+
+  # The maximum allowed length in pixels of color ramp gradient labels.
+  @[JSON::Field(key: "gradientLabelLimit")]
+  property gradient_label_limit : Float64?
+
+  # Vertical offset in pixels for color ramp gradient labels.
+  @[JSON::Field(key: "gradientLabelOffset")]
+  property gradient_label_offset : Float64?
+
+  # The color of the gradient stroke, can be in hex color code or regular color name.
+  @[JSON::Field(key: "gradientStrokeColor")]
+  property gradient_stroke_color : String?
+
+  # The width of the gradient stroke, in pixels.
+  @[JSON::Field(key: "gradientStrokeWidth")]
+  property gradient_stroke_width : Float64?
+
+  # The width of the gradient, in pixels.
+  @[JSON::Field(key: "gradientWidth")]
+  property gradient_width : Float64?
+
+  # The alignment of the legend label, can be left, middle or right.
+  @[JSON::Field(key: "labelAlign")]
+  property label_align : String?
+
+  # The position of the baseline of legend label, can be top, middle or bottom.
+  @[JSON::Field(key: "labelBaseline")]
+  property label_baseline : String?
+
+  # The color of the legend label, can be in hex color code or regular color name.
+  @[JSON::Field(key: "labelColor")]
+  property label_color : String?
+
+  # The font of the legend label.
+  @[JSON::Field(key: "labelFont")]
+  property label_font : String?
+
+  # The font size of legend label.
+  #
+  # __Default value:__ `10`.
+  @[JSON::Field(key: "labelFontSize")]
+  property label_font_size : Float64?
+
+  # Maximum allowed pixel width of axis tick labels.
+  @[JSON::Field(key: "labelLimit")]
+  property label_limit : Float64?
+
+  # The offset of the legend label.
+  @[JSON::Field(key: "labelOffset")]
+  property label_offset : Float64?
+
+  # The offset, in pixels, by which to displace the legend from the edge of the enclosing
+  # group or data rectangle.
+  #
+  # __Default value:__  `0`
+  property offset : Float64?
+
+  # The orientation of the legend, which determines how the legend is positioned within the
+  # scene. One of "left", "right", "top-left", "top-right", "bottom-left", "bottom-right",
+  # "none".
+  #
+  # __Default value:__ `"right"`
+  property orient : String?
+
+  # The padding, in pixels, between the legend and axis.
+  property padding : Float64?
+
+  # Whether month names and weekday names should be abbreviated.
+  #
+  # __Default value:__  `false`
+  @[JSON::Field(key: "shortTimeLabels")]
+  property short_time_labels : Bool?
+
+  # Border stroke color for the full legend.
+  @[JSON::Field(key: "strokeColor")]
+  property stroke_color : String?
+
+  # Border stroke dash pattern for the full legend.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # Border stroke width for the full legend.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # The color of the legend symbol,
+  @[JSON::Field(key: "symbolColor")]
+  property symbol_color : String?
+
+  # The size of the legend symbol, in pixels.
+  @[JSON::Field(key: "symbolSize")]
+  property symbol_size : Float64?
+
+  # The width of the symbol's stroke.
+  @[JSON::Field(key: "symbolStrokeWidth")]
+  property symbol_stroke_width : Float64?
+
+  # Default shape type (such as "circle") for legend symbols.
+  @[JSON::Field(key: "symbolType")]
+  property symbol_type : String?
+
+  # Horizontal text alignment for legend titles.
+  @[JSON::Field(key: "titleAlign")]
+  property title_align : String?
+
+  # Vertical text baseline for legend titles.
+  @[JSON::Field(key: "titleBaseline")]
+  property title_baseline : String?
+
+  # The color of the legend title, can be in hex color code or regular color name.
+  @[JSON::Field(key: "titleColor")]
+  property title_color : String?
+
+  # The font of the legend title.
+  @[JSON::Field(key: "titleFont")]
+  property title_font : String?
+
+  # The font size of the legend title.
+  @[JSON::Field(key: "titleFontSize")]
+  property title_font_size : Float64?
+
+  # The font weight of the legend title.
+  @[JSON::Field(key: "titleFontWeight")]
+  property title_font_weight : TitleFontWeightUnion?
+
+  # Maximum allowed pixel width of axis titles.
+  @[JSON::Field(key: "titleLimit")]
+  property title_limit : Float64?
+
+  # The padding, in pixels, between title and legend.
+  @[JSON::Field(key: "titlePadding")]
+  property title_padding : Float64?
+end
+
+class PaddingClass
+  include JSON::Serializable
+
+  property bottom : Float64?
+
+  property left : Float64?
+
+  property right : Float64?
+
+  property top : Float64?
+end
+
+# Projection configuration, which determines default properties for all
+# [projections](projection.html). For a full list of projection configuration options,
+# please see the [corresponding section of the projection
+# documentation](projection.html#config).
+#
+# Any property of Projection can be in config
+class ProjectionConfig
+  include JSON::Serializable
+
+  # Sets the projection’s center to the specified center, a two-element array of longitude
+  # and latitude in degrees.
+  #
+  # __Default value:__ `[0, 0]`
+  property center : Array(Float64)?
+
+  # Sets the projection’s clipping circle radius to the specified angle in degrees. If
+  # `null`, switches to [antimeridian](http://bl.ocks.org/mbostock/3788999) cutting rather
+  # than small-circle clipping.
+  @[JSON::Field(key: "clipAngle")]
+  property clip_angle : Float64?
+
+  # Sets the projection’s viewport clip extent to the specified bounds in pixels. The extent
+  # bounds are specified as an array `[[x0, y0], [x1, y1]]`, where `x0` is the left-side of
+  # the viewport, `y0` is the top, `x1` is the right and `y1` is the bottom. If `null`, no
+  # viewport clipping is performed.
+  @[JSON::Field(key: "clipExtent")]
+  property clip_extent : Array(Array(Float64))?
+
+  property coefficient : Float64?
+
+  property distance : Float64?
+
+  property fraction : Float64?
+
+  property lobes : Float64?
+
+  property parallel : Float64?
+
+  # Sets the threshold for the projection’s [adaptive
+  # resampling](http://bl.ocks.org/mbostock/3795544) to the specified value in pixels. This
+  # value corresponds to the [Douglas–Peucker
+  # distance](http://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm).
+  # If precision is not specified, returns the projection’s current resampling precision
+  # which defaults to `√0.5 ≅ 0.70710…`.
+  property precision : Hash(String, PrecisionValue)?
+
+  property radius : Float64?
+
+  property ratio : Float64?
+
+  # Sets the projection’s three-axis rotation to the specified angles, which must be a two-
+  # or three-element array of numbers [`lambda`, `phi`, `gamma`] specifying the rotation
+  # angles in degrees about each spherical axis. (These correspond to yaw, pitch and roll.)
+  #
+  # __Default value:__ `[0, 0, 0]`
+  property rotate : Array(Float64)?
+
+  property spacing : Float64?
+
+  property tilt : Float64?
+
+  # The cartographic projection to use. This value is case-insensitive, for example
+  # `"albers"` and `"Albers"` indicate the same projection type. You can find all valid
+  # projection types [in the
+  # documentation](https://vega.github.io/vega-lite/docs/projection.html#projection-types).
+  #
+  # __Default value:__ `mercator`
+  @[JSON::Field(key: "type")]
+  property projection_config_type : String?
+end
+
+class VgScheme
+  include JSON::Serializable
+
+  property count : Float64?
+
+  property extent : Array(Float64)?
+
+  property scheme : String?
+
+  property step : Float64?
+end
+
+# Scale configuration determines default properties for all [scales](scale.html). For a
+# full list of scale configuration options, please see the [corresponding section of the
+# scale documentation](scale.html#config).
+class ScaleConfig
+  include JSON::Serializable
+
+  # Default inner padding for `x` and `y` band-ordinal scales.
+  #
+  # __Default value:__ `0.1`
+  @[JSON::Field(key: "bandPaddingInner")]
+  property band_padding_inner : Float64?
+
+  # Default outer padding for `x` and `y` band-ordinal scales.
+  # If not specified, by default, band scale's paddingOuter is paddingInner/2.
+  @[JSON::Field(key: "bandPaddingOuter")]
+  property band_padding_outer : Float64?
+
+  # If true, values that exceed the data domain are clamped to either the minimum or maximum
+  # range value
+  property clamp : Bool?
+
+  # Default padding for continuous scales.
+  #
+  # __Default:__ `5` for continuous x-scale of a vertical bar and continuous y-scale of a
+  # horizontal bar.; `0` otherwise.
+  @[JSON::Field(key: "continuousPadding")]
+  property continuous_padding : Float64?
+
+  # The default max value for mapping quantitative fields to bar's size/bandSize.
+  #
+  # If undefined (default), we will use the scale's `rangeStep` - 1.
+  @[JSON::Field(key: "maxBandSize")]
+  property max_band_size : Float64?
+
+  # The default max value for mapping quantitative fields to text's size/fontSize.
+  #
+  # __Default value:__ `40`
+  @[JSON::Field(key: "maxFontSize")]
+  property max_font_size : Float64?
+
+  # Default max opacity for mapping a field to opacity.
+  #
+  # __Default value:__ `0.8`
+  @[JSON::Field(key: "maxOpacity")]
+  property max_opacity : Float64?
+
+  # Default max value for point size scale.
+  @[JSON::Field(key: "maxSize")]
+  property max_size : Float64?
+
+  # Default max strokeWidth for strokeWidth  (or rule/line's size) scale.
+  #
+  # __Default value:__ `4`
+  @[JSON::Field(key: "maxStrokeWidth")]
+  property max_stroke_width : Float64?
+
+  # The default min value for mapping quantitative fields to bar and tick's size/bandSize
+  # scale with zero=false.
+  #
+  # __Default value:__ `2`
+  @[JSON::Field(key: "minBandSize")]
+  property min_band_size : Float64?
+
+  # The default min value for mapping quantitative fields to tick's size/fontSize scale with
+  # zero=false
+  #
+  # __Default value:__ `8`
+  @[JSON::Field(key: "minFontSize")]
+  property min_font_size : Float64?
+
+  # Default minimum opacity for mapping a field to opacity.
+  #
+  # __Default value:__ `0.3`
+  @[JSON::Field(key: "minOpacity")]
+  property min_opacity : Float64?
+
+  # Default minimum value for point size scale with zero=false.
+  #
+  # __Default value:__ `9`
+  @[JSON::Field(key: "minSize")]
+  property min_size : Float64?
+
+  # Default minimum strokeWidth for strokeWidth (or rule/line's size) scale with zero=false.
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "minStrokeWidth")]
+  property min_stroke_width : Float64?
+
+  # Default outer padding for `x` and `y` point-ordinal scales.
+  #
+  # __Default value:__ `0.5`
+  @[JSON::Field(key: "pointPadding")]
+  property point_padding : Float64?
+
+  # Default range step for band and point scales of (1) the `y` channel
+  # and (2) the `x` channel when the mark is not `text`.
+  #
+  # __Default value:__ `21`
+  @[JSON::Field(key: "rangeStep")]
+  property range_step : Float64?
+
+  # If true, rounds numeric output values to integers.
+  # This can be helpful for snapping to the pixel grid.
+  # (Only available for `x`, `y`, and `size` scales.)
+  property round : Bool?
+
+  # Default range step for `x` band and point scales of text marks.
+  #
+  # __Default value:__ `90`
+  @[JSON::Field(key: "textXRangeStep")]
+  property text_x_range_step : Float64?
+
+  # Use the source data range before aggregation as scale domain instead of aggregated data
+  # for aggregate axis.
+  #
+  # This is equivalent to setting `domain` to `"unaggregate"` for aggregated _quantitative_
+  # fields by default.
+  #
+  # This property only works with aggregate functions that produce values within the raw data
+  # domain (`"mean"`, `"average"`, `"median"`, `"q1"`, `"q3"`, `"min"`, `"max"`). For other
+  # aggregations that produce values outside of the raw data domain (e.g. `"count"`,
+  # `"sum"`), this property is ignored.
+  #
+  # __Default value:__ `false`
+  @[JSON::Field(key: "useUnaggregatedDomain")]
+  property use_unaggregated_domain : Bool?
+end
+
+# An object hash for defining default properties for each type of selections.
+class SelectionConfig
+  include JSON::Serializable
+
+  # The default definition for an [`interval`](selection.html#type) selection. All properties
+  # and transformations
+  # for an interval selection definition (except `type`) may be specified here.
+  #
+  # For instance, setting `interval` to `{"translate": false}` disables the ability to move
+  # interval selections by default.
+  property interval : IntervalSelectionConfig?
+
+  # The default definition for a [`multi`](selection.html#type) selection. All properties and
+  # transformations
+  # for a multi selection definition (except `type`) may be specified here.
+  #
+  # For instance, setting `multi` to `{"toggle": "event.altKey"}` adds additional values to
+  # multi selections when clicking with the alt-key pressed by default.
+  property multi : MultiSelectionConfig?
+
+  # The default definition for a [`single`](selection.html#type) selection. All properties
+  # and transformations
+  # for a single selection definition (except `type`) may be specified here.
+  #
+  # For instance, setting `single` to `{"on": "dblclick"}` populates single selections on
+  # double-click by default.
+  property single : SingleSelectionConfig?
+end
+
+# The default definition for an [`interval`](selection.html#type) selection. All properties
+# and transformations
+# for an interval selection definition (except `type`) may be specified here.
+#
+# For instance, setting `interval` to `{"translate": false}` disables the ability to move
+# interval selections by default.
+class IntervalSelectionConfig
+  include JSON::Serializable
+
+  # Establishes a two-way binding between the interval selection and the scales
+  # used within the same view. This allows a user to interactively pan and
+  # zoom the view.
+  property bind : String?
+
+  # By default, all data values are considered to lie within an empty selection.
+  # When set to `none`, empty selections contain no data values.
+  property empty : String?
+
+  # An array of encoding channels. The corresponding data field values
+  # must match for a data tuple to fall within the selection.
+  property encodings : Array(String)?
+
+  # An array of field names whose values must match for a data tuple to
+  # fall within the selection.
+  property fields : Array(String)?
+
+  # An interval selection also adds a rectangle mark to depict the
+  # extents of the interval. The `mark` property can be used to customize the
+  # appearance of the mark.
+  property mark : BrushConfig?
+
+  # A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
+  # selector) that triggers the selection.
+  # For interval selections, the event stream must specify a [start and
+  # end](https://vega.github.io/vega/docs/event-streams/#between-filters).
+  property on : JSON::Any?
+
+  # With layered and multi-view displays, a strategy that determines how
+  # selections' data queries are resolved when applied in a filter transform,
+  # conditional encoding rule, or scale domain.
+  property resolve : String?
+
+  # When truthy, allows a user to interactively move an interval selection
+  # back-and-forth. Can be `true`, `false` (to disable panning), or a
+  # [Vega event stream definition](https://vega.github.io/vega/docs/event-streams/)
+  # which must include a start and end event to trigger continuous panning.
+  #
+  # __Default value:__ `true`, which corresponds to
+  # `[mousedown, window:mouseup] > window:mousemove!` which corresponds to
+  # clicks and dragging within an interval selection to reposition it.
+  property translate : Translate?
+
+  # When truthy, allows a user to interactively resize an interval selection.
+  # Can be `true`, `false` (to disable zooming), or a [Vega event stream
+  # definition](https://vega.github.io/vega/docs/event-streams/). Currently,
+  # only `wheel` events are supported.
+  #
+  #
+  # __Default value:__ `true`, which corresponds to `wheel!`.
+  property zoom : Translate?
+end
+
+# An interval selection also adds a rectangle mark to depict the
+# extents of the interval. The `mark` property can be used to customize the
+# appearance of the mark.
+class BrushConfig
+  include JSON::Serializable
+
+  # The fill color of the interval mark.
+  #
+  # __Default value:__ `#333333`
+  property fill : String?
+
+  # The fill opacity of the interval mark (a value between 0 and 1).
+  #
+  # __Default value:__ `0.125`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The stroke color of the interval mark.
+  #
+  # __Default value:__ `#ffffff`
+  property stroke : String?
+
+  # An array of alternating stroke and space lengths,
+  # for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) with which to begin drawing the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity of the interval mark (a value between 0 and 1).
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width of the interval mark.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+end
+
+# The default definition for a [`multi`](selection.html#type) selection. All properties and
+# transformations
+# for a multi selection definition (except `type`) may be specified here.
+#
+# For instance, setting `multi` to `{"toggle": "event.altKey"}` adds additional values to
+# multi selections when clicking with the alt-key pressed by default.
+class MultiSelectionConfig
+  include JSON::Serializable
+
+  # By default, all data values are considered to lie within an empty selection.
+  # When set to `none`, empty selections contain no data values.
+  property empty : String?
+
+  # An array of encoding channels. The corresponding data field values
+  # must match for a data tuple to fall within the selection.
+  property encodings : Array(String)?
+
+  # An array of field names whose values must match for a data tuple to
+  # fall within the selection.
+  property fields : Array(String)?
+
+  # When true, an invisible voronoi diagram is computed to accelerate discrete
+  # selection. The data value _nearest_ the mouse cursor is added to the selection.
+  #
+  # See the [nearest transform](nearest.html) documentation for more information.
+  property nearest : Bool?
+
+  # A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
+  # selector) that triggers the selection.
+  # For interval selections, the event stream must specify a [start and
+  # end](https://vega.github.io/vega/docs/event-streams/#between-filters).
+  property on : JSON::Any?
+
+  # With layered and multi-view displays, a strategy that determines how
+  # selections' data queries are resolved when applied in a filter transform,
+  # conditional encoding rule, or scale domain.
+  property resolve : String?
+
+  # Controls whether data values should be toggled or only ever inserted into
+  # multi selections. Can be `true`, `false` (for insertion only), or a
+  # [Vega expression](https://vega.github.io/vega/docs/expressions/).
+  #
+  # __Default value:__ `true`, which corresponds to `event.shiftKey` (i.e.,
+  # data values are toggled when a user interacts with the shift-key pressed).
+  #
+  # See the [toggle transform](toggle.html) documentation for more information.
+  property toggle : Translate?
+end
+
+# The default definition for a [`single`](selection.html#type) selection. All properties
+# and transformations
+# for a single selection definition (except `type`) may be specified here.
+#
+# For instance, setting `single` to `{"on": "dblclick"}` populates single selections on
+# double-click by default.
+class SingleSelectionConfig
+  include JSON::Serializable
+
+  # Establish a two-way binding between a single selection and input elements
+  # (also known as dynamic query widgets). A binding takes the form of
+  # Vega's [input element binding definition](https://vega.github.io/vega/docs/signals/#bind)
+  # or can be a mapping between projected field/encodings and binding definitions.
+  #
+  # See the [bind transform](bind.html) documentation for more information.
+  property bind : Hash(String, VgBinding)?
+
+  # By default, all data values are considered to lie within an empty selection.
+  # When set to `none`, empty selections contain no data values.
+  property empty : String?
+
+  # An array of encoding channels. The corresponding data field values
+  # must match for a data tuple to fall within the selection.
+  property encodings : Array(String)?
+
+  # An array of field names whose values must match for a data tuple to
+  # fall within the selection.
+  property fields : Array(String)?
+
+  # When true, an invisible voronoi diagram is computed to accelerate discrete
+  # selection. The data value _nearest_ the mouse cursor is added to the selection.
+  #
+  # See the [nearest transform](nearest.html) documentation for more information.
+  property nearest : Bool?
+
+  # A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
+  # selector) that triggers the selection.
+  # For interval selections, the event stream must specify a [start and
+  # end](https://vega.github.io/vega/docs/event-streams/#between-filters).
+  property on : JSON::Any?
+
+  # With layered and multi-view displays, a strategy that determines how
+  # selections' data queries are resolved when applied in a filter transform,
+  # conditional encoding rule, or scale domain.
+  property resolve : String?
+end
+
+class VgBinding
+  include JSON::Serializable
+
+  property element : String?
+
+  property input : String
+
+  property options : Array(String)?
+
+  property max : Float64?
+
+  property min : Float64?
+
+  property step : Float64?
+end
+
+class VgMarkConfig
+  include JSON::Serializable
+
+  # The horizontal alignment of the text. One of `"left"`, `"right"`, `"center"`.
+  property align : String?
+
+  # The rotation angle of the text, in degrees.
+  property angle : Float64?
+
+  # The vertical alignment of the text. One of `"top"`, `"middle"`, `"bottom"`.
+  #
+  # __Default value:__ `"middle"`
+  property baseline : String?
+
+  # The mouse cursor used over the mark. Any valid [CSS cursor
+  # type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
+  property cursor : String?
+
+  # The horizontal offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dx : Float64?
+
+  # The vertical offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dy : Float64?
+
+  # Default Fill Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property fill : String?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The typeface to set the text in (e.g., `"Helvetica Neue"`).
+  property font : String?
+
+  # The font size, in pixels.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # The font style (e.g., `"italic"`).
+  @[JSON::Field(key: "fontStyle")]
+  property font_style : String?
+
+  # The font weight (e.g., `"bold"`).
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # A URL to load upon mouse click. If defined, the mark acts as a hyperlink.
+  property href : String?
+
+  # The line interpolation method to use for line and area marks. One of the following:
+  # - `"linear"`: piecewise linear segments, as in a polyline.
+  # - `"linear-closed"`: close the linear segments to form a polygon.
+  # - `"step"`: alternate between horizontal and vertical segments, as in a step function.
+  # - `"step-before"`: alternate between vertical and horizontal segments, as in a step
+  # function.
+  # - `"step-after"`: alternate between horizontal and vertical segments, as in a step
+  # function.
+  # - `"basis"`: a B-spline, with control point duplication on the ends.
+  # - `"basis-open"`: an open B-spline; may not intersect the start or end.
+  # - `"basis-closed"`: a closed B-spline, as in a loop.
+  # - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
+  # - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
+  # will intersect other control points.
+  # - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
+  # - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
+  # spline.
+  # - `"monotone"`: cubic interpolation that preserves monotonicity in y.
+  property interpolate : String?
+
+  # The maximum length of the text mark in pixels (default 0, indicating no limit). The text
+  # value will be automatically truncated if the rendered size exceeds the limit.
+  property limit : Float64?
+
+  # The overall opacity (value between [0,1]).
+  #
+  # __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
+  # `square` marks or layered `bar` charts and `1` otherwise.
+  property opacity : Float64?
+
+  # The orientation of a non-stacked bar, tick, area, and line charts.
+  # The value is either horizontal (default) or vertical.
+  # - For bar, rule and tick, this determines whether the size of the bar and tick
+  # should be applied to x or y dimension.
+  # - For area, this property determines the orient property of the Vega output.
+  # - For line, this property determines the sort order of the points in the line
+  # if `config.sortLineBy` is not specified.
+  # For stacked charts, this is always determined by the orientation of the stack;
+  # therefore explicitly specified value will be ignored.
+  property orient : String?
+
+  # Polar coordinate radial offset, in pixels, of the text label from the origin determined
+  # by the `x` and `y` properties.
+  property radius : Float64?
+
+  # The default symbol shape to use. One of: `"circle"` (default), `"square"`, `"cross"`,
+  # `"diamond"`, `"triangle-up"`, or `"triangle-down"`, or a custom SVG path.
+  #
+  # __Default value:__ `"circle"`
+  property shape : String?
+
+  # The pixel area each the point/circle/square.
+  # For example: in the case of circles, the radius is determined in part by the square root
+  # of the size value.
+  #
+  # __Default value:__ `30`
+  property size : Float64?
+
+  # Default Stroke Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # Depending on the interpolation type, sets the tension parameter (for line and area marks).
+  property tension : Float64?
+
+  # Placeholder text if the `text` channel is not specified
+  property text : String?
+
+  # Polar coordinate angle, in radians, of the text label from the origin determined by the
+  # `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark
+  # `startAngle` and `endAngle` properties: angles are measured in radians, with `0`
+  # indicating "north".
+  property theta : Float64?
+end
+
+# Text-Specific Config
+class TextConfig
+  include JSON::Serializable
+
+  # The horizontal alignment of the text. One of `"left"`, `"right"`, `"center"`.
+  property align : String?
+
+  # The rotation angle of the text, in degrees.
+  property angle : Float64?
+
+  # The vertical alignment of the text. One of `"top"`, `"middle"`, `"bottom"`.
+  #
+  # __Default value:__ `"middle"`
+  property baseline : String?
+
+  # Default color.  Note that `fill` and `stroke` have higher precedence than `color` and
+  # will override `color`.
+  #
+  # __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property color : String?
+
+  # The mouse cursor used over the mark. Any valid [CSS cursor
+  # type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
+  property cursor : String?
+
+  # The horizontal offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dx : Float64?
+
+  # The vertical offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dy : Float64?
+
+  # Default Fill Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property fill : String?
+
+  # Whether the mark's color should be used as fill color instead of stroke color.
+  #
+  # __Default value:__ `true` for all marks except `point` and `false` for `point`.
+  #
+  # __Applicable for:__ `bar`, `point`, `circle`, `square`, and `area` marks.
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property filled : Bool?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The typeface to set the text in (e.g., `"Helvetica Neue"`).
+  property font : String?
+
+  # The font size, in pixels.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # The font style (e.g., `"italic"`).
+  @[JSON::Field(key: "fontStyle")]
+  property font_style : String?
+
+  # The font weight (e.g., `"bold"`).
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # A URL to load upon mouse click. If defined, the mark acts as a hyperlink.
+  property href : String?
+
+  # The line interpolation method to use for line and area marks. One of the following:
+  # - `"linear"`: piecewise linear segments, as in a polyline.
+  # - `"linear-closed"`: close the linear segments to form a polygon.
+  # - `"step"`: alternate between horizontal and vertical segments, as in a step function.
+  # - `"step-before"`: alternate between vertical and horizontal segments, as in a step
+  # function.
+  # - `"step-after"`: alternate between horizontal and vertical segments, as in a step
+  # function.
+  # - `"basis"`: a B-spline, with control point duplication on the ends.
+  # - `"basis-open"`: an open B-spline; may not intersect the start or end.
+  # - `"basis-closed"`: a closed B-spline, as in a loop.
+  # - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
+  # - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
+  # will intersect other control points.
+  # - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
+  # - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
+  # spline.
+  # - `"monotone"`: cubic interpolation that preserves monotonicity in y.
+  property interpolate : String?
+
+  # The maximum length of the text mark in pixels (default 0, indicating no limit). The text
+  # value will be automatically truncated if the rendered size exceeds the limit.
+  property limit : Float64?
+
+  # The overall opacity (value between [0,1]).
+  #
+  # __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
+  # `square` marks or layered `bar` charts and `1` otherwise.
+  property opacity : Float64?
+
+  # The orientation of a non-stacked bar, tick, area, and line charts.
+  # The value is either horizontal (default) or vertical.
+  # - For bar, rule and tick, this determines whether the size of the bar and tick
+  # should be applied to x or y dimension.
+  # - For area, this property determines the orient property of the Vega output.
+  # - For line, this property determines the sort order of the points in the line
+  # if `config.sortLineBy` is not specified.
+  # For stacked charts, this is always determined by the orientation of the stack;
+  # therefore explicitly specified value will be ignored.
+  property orient : String?
+
+  # Polar coordinate radial offset, in pixels, of the text label from the origin determined
+  # by the `x` and `y` properties.
+  property radius : Float64?
+
+  # The default symbol shape to use. One of: `"circle"` (default), `"square"`, `"cross"`,
+  # `"diamond"`, `"triangle-up"`, or `"triangle-down"`, or a custom SVG path.
+  #
+  # __Default value:__ `"circle"`
+  property shape : String?
+
+  # Whether month names and weekday names should be abbreviated.
+  @[JSON::Field(key: "shortTimeLabels")]
+  property short_time_labels : Bool?
+
+  # The pixel area each the point/circle/square.
+  # For example: in the case of circles, the radius is determined in part by the square root
+  # of the size value.
+  #
+  # __Default value:__ `30`
+  property size : Float64?
+
+  # Default Stroke Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # Depending on the interpolation type, sets the tension parameter (for line and area marks).
+  property tension : Float64?
+
+  # Placeholder text if the `text` channel is not specified
+  property text : String?
+
+  # Polar coordinate angle, in radians, of the text label from the origin determined by the
+  # `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark
+  # `startAngle` and `endAngle` properties: angles are measured in radians, with `0`
+  # indicating "north".
+  property theta : Float64?
+end
+
+# Tick-Specific Config
+class TickConfig
+  include JSON::Serializable
+
+  # The horizontal alignment of the text. One of `"left"`, `"right"`, `"center"`.
+  property align : String?
+
+  # The rotation angle of the text, in degrees.
+  property angle : Float64?
+
+  # The width of the ticks.
+  #
+  # __Default value:__  2/3 of rangeStep.
+  @[JSON::Field(key: "bandSize")]
+  property band_size : Float64?
+
+  # The vertical alignment of the text. One of `"top"`, `"middle"`, `"bottom"`.
+  #
+  # __Default value:__ `"middle"`
+  property baseline : String?
+
+  # Default color.  Note that `fill` and `stroke` have higher precedence than `color` and
+  # will override `color`.
+  #
+  # __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property color : String?
+
+  # The mouse cursor used over the mark. Any valid [CSS cursor
+  # type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
+  property cursor : String?
+
+  # The horizontal offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dx : Float64?
+
+  # The vertical offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dy : Float64?
+
+  # Default Fill Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property fill : String?
+
+  # Whether the mark's color should be used as fill color instead of stroke color.
+  #
+  # __Default value:__ `true` for all marks except `point` and `false` for `point`.
+  #
+  # __Applicable for:__ `bar`, `point`, `circle`, `square`, and `area` marks.
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property filled : Bool?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The typeface to set the text in (e.g., `"Helvetica Neue"`).
+  property font : String?
+
+  # The font size, in pixels.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # The font style (e.g., `"italic"`).
+  @[JSON::Field(key: "fontStyle")]
+  property font_style : String?
+
+  # The font weight (e.g., `"bold"`).
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # A URL to load upon mouse click. If defined, the mark acts as a hyperlink.
+  property href : String?
+
+  # The line interpolation method to use for line and area marks. One of the following:
+  # - `"linear"`: piecewise linear segments, as in a polyline.
+  # - `"linear-closed"`: close the linear segments to form a polygon.
+  # - `"step"`: alternate between horizontal and vertical segments, as in a step function.
+  # - `"step-before"`: alternate between vertical and horizontal segments, as in a step
+  # function.
+  # - `"step-after"`: alternate between horizontal and vertical segments, as in a step
+  # function.
+  # - `"basis"`: a B-spline, with control point duplication on the ends.
+  # - `"basis-open"`: an open B-spline; may not intersect the start or end.
+  # - `"basis-closed"`: a closed B-spline, as in a loop.
+  # - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
+  # - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
+  # will intersect other control points.
+  # - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
+  # - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
+  # spline.
+  # - `"monotone"`: cubic interpolation that preserves monotonicity in y.
+  property interpolate : String?
+
+  # The maximum length of the text mark in pixels (default 0, indicating no limit). The text
+  # value will be automatically truncated if the rendered size exceeds the limit.
+  property limit : Float64?
+
+  # The overall opacity (value between [0,1]).
+  #
+  # __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
+  # `square` marks or layered `bar` charts and `1` otherwise.
+  property opacity : Float64?
+
+  # The orientation of a non-stacked bar, tick, area, and line charts.
+  # The value is either horizontal (default) or vertical.
+  # - For bar, rule and tick, this determines whether the size of the bar and tick
+  # should be applied to x or y dimension.
+  # - For area, this property determines the orient property of the Vega output.
+  # - For line, this property determines the sort order of the points in the line
+  # if `config.sortLineBy` is not specified.
+  # For stacked charts, this is always determined by the orientation of the stack;
+  # therefore explicitly specified value will be ignored.
+  property orient : String?
+
+  # Polar coordinate radial offset, in pixels, of the text label from the origin determined
+  # by the `x` and `y` properties.
+  property radius : Float64?
+
+  # The default symbol shape to use. One of: `"circle"` (default), `"square"`, `"cross"`,
+  # `"diamond"`, `"triangle-up"`, or `"triangle-down"`, or a custom SVG path.
+  #
+  # __Default value:__ `"circle"`
+  property shape : String?
+
+  # The pixel area each the point/circle/square.
+  # For example: in the case of circles, the radius is determined in part by the square root
+  # of the size value.
+  #
+  # __Default value:__ `30`
+  property size : Float64?
+
+  # Default Stroke Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # Depending on the interpolation type, sets the tension parameter (for line and area marks).
+  property tension : Float64?
+
+  # Placeholder text if the `text` channel is not specified
+  property text : String?
+
+  # Polar coordinate angle, in radians, of the text label from the origin determined by the
+  # `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark
+  # `startAngle` and `endAngle` properties: angles are measured in radians, with `0`
+  # indicating "north".
+  property theta : Float64?
+
+  # Thickness of the tick mark.
+  #
+  # __Default value:__  `1`
+  property thickness : Float64?
+end
+
+# Title configuration, which determines default properties for all [titles](title.html).
+# For a full list of title configuration options, please see the [corresponding section of
+# the title documentation](title.html#config).
+class VgTitleConfig
+  include JSON::Serializable
+
+  # The anchor position for placing the title. One of `"start"`, `"middle"`, or `"end"`. For
+  # example, with an orientation of top these anchor positions map to a left-, center-, or
+  # right-aligned title.
+  #
+  # __Default value:__ `"middle"` for [single](spec.html) and [layered](layer.html) views.
+  # `"start"` for other composite views.
+  #
+  # __Note:__ [For now](https://github.com/vega/vega-lite/issues/2875), `anchor` is only
+  # customizable only for [single](spec.html) and [layered](layer.html) views.  For other
+  # composite views, `anchor` is always `"start"`.
+  property anchor : String?
+
+  # Angle in degrees of title text.
+  property angle : Float64?
+
+  # Vertical text baseline for title text.
+  property baseline : String?
+
+  # Text color for title text.
+  property color : String?
+
+  # Font name for title text.
+  property font : String?
+
+  # Font size in pixels for title text.
+  #
+  # __Default value:__ `10`.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # Font weight for title text.
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # The maximum allowed length in pixels of legend labels.
+  property limit : Float64?
+
+  # Offset in pixels of the title from the chart body and axes.
+  property offset : Float64?
+
+  # Default title orientation ("top", "bottom", "left", or "right")
+  property orient : String?
+end
+
+# Default properties for [single view plots](spec.html#single).
+class ViewConfig
+  include JSON::Serializable
+
+  # Whether the view should be clipped.
+  property clip : Bool?
+
+  # The fill color.
+  #
+  # __Default value:__ (none)
+  property fill : String?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ (none)
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The default height of the single plot or each plot in a trellis plot when the
+  # visualization has a continuous (non-ordinal) y-scale with `rangeStep` = `null`.
+  #
+  # __Default value:__ `200`
+  property height : Float64?
+
+  # The stroke color.
+  #
+  # __Default value:__ (none)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  #
+  # __Default value:__ (none)
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  #
+  # __Default value:__ (none)
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ (none)
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  #
+  # __Default value:__ (none)
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # The default width of the single plot or each plot in a trellis plot when the
+  # visualization has a continuous (non-ordinal) x-scale or ordinal x-scale with `rangeStep`
+  # = `null`.
+  #
+  # __Default value:__ `200`
+  property width : Float64?
+end
+
+# An object describing the data source
+#
+# Secondary data source to lookup in.
+class Data
+  include JSON::Serializable
+
+  # An object that specifies the format for parsing the data file.
+  #
+  # An object that specifies the format for parsing the data values.
+  #
+  # An object that specifies the format for parsing the data.
+  property format : DataFormat?
+
+  # An URL from which to load the data set. Use the `format.type` property
+  # to ensure the loaded data is correctly parsed.
+  property url : String?
+
+  # The full data set, included inline. This can be an array of objects or primitive values
+  # or a string.
+  # Arrays of primitive values are ingested as objects with a `data` property. Strings are
+  # parsed according to the specified format type.
+  property values : Values?
+
+  # Provide a placeholder name and bind data at runtime.
+  property name : String?
+end
+
+# An object that specifies the format for parsing the data file.
+#
+# An object that specifies the format for parsing the data values.
+#
+# An object that specifies the format for parsing the data.
+class DataFormat
+  include JSON::Serializable
+
+  # If set to auto (the default), perform automatic type inference to determine the desired
+  # data types.
+  # Alternatively, a parsing directive object can be provided for explicit data types. Each
+  # property of the object corresponds to a field name, and the value to the desired data
+  # type (one of `"number"`, `"boolean"` or `"date"`).
+  # For example, `"parse": {"modified_on": "date"}` parses the `modified_on` field in each
+  # input record a Date value.
+  #
+  # For `"date"`, we parse data based using Javascript's
+  # [`Date.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse).
+  # For Specific date formats can be provided (e.g., `{foo: 'date:"%m%d%Y"'}`), using the
+  # [d3-time-format syntax](https://github.com/d3/d3-time-format#locale_format). UTC date
+  # format parsing is supported similarly (e.g., `{foo: 'utc:"%m%d%Y"'}`). See more about
+  # [UTC time](timeunit.html#utc)
+  property parse : ParseUnion?
+
+  # Type of input data: `"json"`, `"csv"`, `"tsv"`.
+  # The default format type is determined by the extension of the file URL.
+  # If no extension is detected, `"json"` will be used by default.
+  @[JSON::Field(key: "type")]
+  property data_format_type : String?
+
+  # The JSON property containing the desired data.
+  # This parameter can be used when the loaded JSON file may have surrounding structure or
+  # meta-data.
+  # For example `"property": "values.features"` is equivalent to retrieving
+  # `json.values.features`
+  # from the loaded JSON object.
+  property property : String?
+
+  # The name of the TopoJSON object set to convert to a GeoJSON feature collection.
+  # For example, in a map of the world, there may be an object set named `"countries"`.
+  # Using the feature property, we can extract this set and generate a GeoJSON feature object
+  # for each country.
+  property feature : String?
+
+  # The name of the TopoJSON object set to convert to mesh.
+  # Similar to the `feature` option, `mesh` extracts a named TopoJSON object set.
+  # Unlike the `feature` option, the corresponding geo data is returned as a single, unified
+  # mesh instance, not as individual GeoJSON features.
+  # Extracting a mesh is useful for more efficiently drawing borders or other geographic
+  # elements that you do not need to associate with specific regions such as individual
+  # countries, states or counties.
+  property mesh : String?
+end
+
+# A key-value mapping between encoding channels and definition of fields.
+class EncodingWithFacet
+  include JSON::Serializable
+
+  # Color of the marks – either fill or stroke color based on mark type.
+  # By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
+  # `"text"`, `"circle"`, and `"square"` / stroke color for `"line"` and `"point"`.
+  #
+  # __Default value:__ If undefined, the default color depends on [mark
+  # config](config.html#mark)'s `color` property.
+  #
+  # _Note:_ See the scale documentation for more information about customizing [color
+  # scheme](scale.html#scheme).
+  property color : MarkPropDefWithCondition?
+
+  # Horizontal facets for trellis plots.
+  property column : FacetFieldDef?
+
+  # Additional levels of detail for grouping data in aggregate views and
+  # in line and area marks without mapping data to a specific visual channel.
+  property detail : Detail?
+
+  # A URL to load upon mouse click.
+  property href : DefWithCondition?
+
+  # Opacity of the marks – either can be a value or a range.
+  #
+  # __Default value:__ If undefined, the default opacity depends on [mark
+  # config](config.html#mark)'s `opacity` property.
+  property opacity : MarkPropDefWithCondition?
+
+  # Stack order for stacked marks or order of data points in line marks for connected scatter
+  # plots.
+  #
+  # __Note__: In aggregate plots, `order` field should be `aggregate`d to avoid creating
+  # additional aggregation grouping.
+  property order : Order?
+
+  # Vertical facets for trellis plots.
+  property row : FacetFieldDef?
+
+  # For `point` marks the supported values are
+  # `"circle"` (default), `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`,
+  # or `"triangle-down"`, or else a custom SVG path string.
+  # For `geoshape` marks it should be a field definition of the geojson data
+  #
+  # __Default value:__ If undefined, the default shape depends on [mark
+  # config](config.html#point-config)'s `shape` property.
+  property shape : MarkPropDefWithCondition?
+
+  # Size of the mark.
+  # - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
+  # - For `"bar"` and `"tick"` – the bar and tick's size.
+  # - For `"text"` – the text's font size.
+  # - Size is currently unsupported for `"line"`, `"area"`, and `"rect"`.
+  property size : MarkPropDefWithCondition?
+
+  # Text of the `text` mark.
+  property text : TextDefWithCondition?
+
+  # The tooltip text to show upon mouse hover.
+  property tooltip : TextDefWithCondition?
+
+  # X coordinates of the marks, or width of horizontal `"bar"` and `"area"`.
+  property x : XClass?
+
+  # X2 coordinates for ranged  `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
+  property x2 : X2Class?
+
+  # Y coordinates of the marks, or height of vertical `"bar"` and `"area"`.
+  property y : XClass?
+
+  # Y2 coordinates for ranged  `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
+  property y2 : X2Class?
+end
+
+# Color of the marks – either fill or stroke color based on mark type.
+# By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
+# `"text"`, `"circle"`, and `"square"` / stroke color for `"line"` and `"point"`.
+#
+# __Default value:__ If undefined, the default color depends on [mark
+# config](config.html#mark)'s `color` property.
+#
+# _Note:_ See the scale documentation for more information about customizing [color
+# scheme](scale.html#scheme).
+#
+# Opacity of the marks – either can be a value or a range.
+#
+# __Default value:__ If undefined, the default opacity depends on [mark
+# config](config.html#mark)'s `opacity` property.
+#
+# For `point` marks the supported values are
+# `"circle"` (default), `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`,
+# or `"triangle-down"`, or else a custom SVG path string.
+# For `geoshape` marks it should be a field definition of the geojson data
+#
+# __Default value:__ If undefined, the default shape depends on [mark
+# config](config.html#point-config)'s `shape` property.
+#
+# Size of the mark.
+# - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
+# - For `"bar"` and `"tick"` – the bar and tick's size.
+# - For `"text"` – the text's font size.
+# - Size is currently unsupported for `"line"`, `"area"`, and `"rect"`.
+#
+# A FieldDef with Condition<ValueDef>
+# {
+# condition: {value: ...},
+# field: ...,
+# ...
+# }
+#
+# A ValueDef with Condition<ValueDef | FieldDef>
+# {
+# condition: {field: ...} | {value: ...},
+# value: ...,
+# }
+class MarkPropDefWithCondition
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # One or more value definition(s) with a selection predicate.
+  #
+  # __Note:__ A field definition's `condition` property can only contain [value
+  # definitions](encoding.html#value-def)
+  # since Vega-Lite only allows at most one encoded field per encoding channel.
+  #
+  # A field definition or one or more value definition(s) with a selection predicate.
+  property condition : ColorCondition?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # An object defining properties of the legend.
+  # If `null`, the legend for the encoding channel will be removed.
+  #
+  # __Default value:__ If undefined, default [legend properties](legend.html) are applied.
+  property legend : Legend?
+
+  # An object defining properties of the channel's scale, which is the function that
+  # transforms values in the data domain (numbers, dates, strings, etc) to visual values
+  # (pixels, colors, sizes) of the encoding channels.
+  #
+  # __Default value:__ If undefined, default [scale properties](scale.html) are applied.
+  property scale : Scale?
+
+  # Sort order for the encoded field.
+  # Supported `sort` values include `"ascending"`, `"descending"` and `null` (no sorting).
+  # For fields with discrete domains, `sort` can also be a [sort field definition
+  # object](sort.html#sort-field).
+  #
+  # __Default value:__ `"ascending"`
+  property sort : SortUnion?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property mark_prop_def_with_condition_type : String?
+
+  # A constant value in visual domain.
+  property value : ConditionalPredicateValueDefValue?
+end
+
+# Binning properties or boolean flag for determining whether to bin data or not.
+class BinParams
+  include JSON::Serializable
+
+  # The number base to use for automatic bin determination (default is base 10).
+  #
+  # __Default value:__ `10`
+  property base : Float64?
+
+  # Scale factors indicating allowable subdivisions. The default value is [5, 2], which
+  # indicates that for base 10 numbers (the default base), the method may consider dividing
+  # bin sizes by 5 and/or 2. For example, for an initial step size of 10, the method can
+  # check if bin sizes of 2 (= 10/5), 5 (= 10/2), or 1 (= 10/(5*2)) might also satisfy the
+  # given constraints.
+  #
+  # __Default value:__ `[5, 2]`
+  property divide : Array(Float64)?
+
+  # A two-element (`[min, max]`) array indicating the range of desired bin values.
+  property extent : Array(Float64)?
+
+  # Maximum number of bins.
+  #
+  # __Default value:__ `6` for `row`, `column` and `shape` channels; `10` for other channels
+  property maxbins : Float64?
+
+  # A minimum allowable step size (particularly useful for integer values).
+  property minstep : Float64?
+
+  # If true (the default), attempts to make the bin boundaries use human-friendly boundaries,
+  # such as multiples of ten.
+  property nice : Bool?
+
+  # An exact step size to use between bins.
+  #
+  # __Note:__ If provided, options such as maxbins will be ignored.
+  property step : Float64?
+
+  # An array of allowable step sizes to choose from.
+  property steps : Array(Float64)?
+end
+
+class ConditionalValueDef
+  include JSON::Serializable
+
+  property test : ConditionalValueDefLogicalOperandPredicate?
+
+  # A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+  # `0` to `1` for opacity).
+  property value : ConditionalValueDefValue
+
+  # A [selection name](selection.html), or a series of [composed
+  # selections](selection.html#compose).
+  property selection : ConditionalValueDefSelectionOperand?
+end
+
+class Selection
+  include JSON::Serializable
+
+  property not : ConditionalValueDefSelectionOperand?
+
+  property and : Array(SelectionOperandElement)?
+
+  property or : Array(SelectionOperandElement)?
+end
+
+class Predicate
+  include JSON::Serializable
+
+  property not : ConditionalValueDefLogicalOperandPredicate?
+
+  property and : Array(LogicalOperandPredicateElement)?
+
+  property or : Array(LogicalOperandPredicateElement)?
+
+  # The value that the field should be equal to.
+  property equal : EqualUnion?
+
+  # Field to be filtered.
+  #
+  # Field to be filtered
+  property field : String?
+
+  # Time unit for the field to be filtered.
+  #
+  # time unit for the field to be filtered.
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # An array of inclusive minimum and maximum values
+  # for a field value of a data item to be included in the filtered data.
+  property range : Array(RangeElement?)?
+
+  # A set of values that the `field`'s value should be a member of,
+  # for a data item included in the filtered data.
+  @[JSON::Field(key: "oneOf")]
+  property one_of : Array(OneOfElement)?
+
+  # Filter using a selection name.
+  property selection : ConditionalValueDefSelectionOperand?
+end
+
+# Object for defining datetime in Vega-Lite Filter.
+# If both month and quarter are provided, month has higher precedence.
+# `day` cannot be combined with other date.
+# We accept string for month and day names.
+class DateTime
+  include JSON::Serializable
+
+  # Integer value representing the date from 1-31.
+  property date : Float64?
+
+  # Value representing the day of a week.  This can be one of: (1) integer value -- `1`
+  # represents Monday; (2) case-insensitive day name (e.g., `"Monday"`);  (3)
+  # case-insensitive, 3-character short day name (e.g., `"Mon"`).   <br/> **Warning:** A
+  # DateTime definition object with `day`** should not be combined with `year`, `quarter`,
+  # `month`, or `date`.
+  property day : Day?
+
+  # Integer value representing the hour of a day from 0-23.
+  property hours : Float64?
+
+  # Integer value representing the millisecond segment of time.
+  property milliseconds : Float64?
+
+  # Integer value representing the minute segment of time from 0-59.
+  property minutes : Float64?
+
+  # One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
+  # (2) case-insensitive month name (e.g., `"January"`);  (3) case-insensitive, 3-character
+  # short month name (e.g., `"Jan"`).
+  property month : Month?
+
+  # Integer value representing the quarter of the year (from 1-4).
+  property quarter : Float64?
+
+  # Integer value representing the second segment (0-59) of a time value
+  property seconds : Float64?
+
+  # A boolean flag indicating if date time is in utc time. If false, the date time is in
+  # local time
+  property utc : Bool?
+
+  # Integer value representing the year.
+  property year : Float64?
+end
+
+class ConditionalPredicateMarkPropFieldDefClass
+  include JSON::Serializable
+
+  property test : ConditionalValueDefLogicalOperandPredicate?
+
+  # A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+  # `0` to `1` for opacity).
+  property value : ConditionalPredicateValueDefValue?
+
+  # A [selection name](selection.html), or a series of [composed
+  # selections](selection.html#compose).
+  property selection : ConditionalValueDefSelectionOperand?
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # An object defining properties of the legend.
+  # If `null`, the legend for the encoding channel will be removed.
+  #
+  # __Default value:__ If undefined, default [legend properties](legend.html) are applied.
+  property legend : Legend?
+
+  # An object defining properties of the channel's scale, which is the function that
+  # transforms values in the data domain (numbers, dates, strings, etc) to visual values
+  # (pixels, colors, sizes) of the encoding channels.
+  #
+  # __Default value:__ If undefined, default [scale properties](scale.html) are applied.
+  property scale : Scale?
+
+  # Sort order for the encoded field.
+  # Supported `sort` values include `"ascending"`, `"descending"` and `null` (no sorting).
+  # For fields with discrete domains, `sort` can also be a [sort field definition
+  # object](sort.html#sort-field).
+  #
+  # __Default value:__ `"ascending"`
+  property sort : SortUnion?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property conditional_def_type : String?
+end
+
+# Reference to a repeated value.
+class RepeatRef
+  include JSON::Serializable
+
+  property repeat : String
+end
+
+# Properties of a legend or boolean flag for determining whether to show it.
+class Legend
+  include JSON::Serializable
+
+  # Padding (in pixels) between legend entries in a symbol legend.
+  @[JSON::Field(key: "entryPadding")]
+  property entry_padding : Float64?
+
+  # The formatting pattern for labels. This is D3's [number format
+  # pattern](https://github.com/d3/d3-format#locale_format) for quantitative fields and D3's
+  # [time format pattern](https://github.com/d3/d3-time-format#locale_format) for time
+  # field.
+  #
+  # See the [format documentation](format.html) for more information.
+  #
+  # __Default value:__  derived from [numberFormat](config.html#format) config for
+  # quantitative fields and from [timeFormat](config.html#format) config for temporal fields.
+  property format : String?
+
+  # The offset, in pixels, by which to displace the legend from the edge of the enclosing
+  # group or data rectangle.
+  #
+  # __Default value:__  `0`
+  property offset : Float64?
+
+  # The orientation of the legend, which determines how the legend is positioned within the
+  # scene. One of "left", "right", "top-left", "top-right", "bottom-left", "bottom-right",
+  # "none".
+  #
+  # __Default value:__ `"right"`
+  property orient : String?
+
+  # The padding, in pixels, between the legend and axis.
+  property padding : Float64?
+
+  # The desired number of tick values for quantitative legends.
+  @[JSON::Field(key: "tickCount")]
+  property tick_count : Float64?
+
+  # A title for the field. If `null`, the title will be removed.
+  #
+  # __Default value:__  derived from the field's name and transformation function
+  # (`aggregate`, `bin` and `timeUnit`).  If the field has an aggregate function, the
+  # function is displayed as a part of the title (e.g., `"Sum of Profit"`). If the field is
+  # binned or has a time unit applied, the applied function will be denoted in parentheses
+  # (e.g., `"Profit (binned)"`, `"Transaction Date (year-month)"`).  Otherwise, the title is
+  # simply the field name.
+  #
+  # __Note__: You can customize the default field title format by providing the [`fieldTitle`
+  # property in the [config](config.html) or [`fieldTitle` function via the `compile`
+  # function's options](compile.html#field-title).
+  property title : String?
+
+  # The type of the legend. Use `"symbol"` to create a discrete legend and `"gradient"` for a
+  # continuous color gradient.
+  #
+  # __Default value:__ `"gradient"` for non-binned quantitative fields and temporal fields;
+  # `"symbol"` otherwise.
+  @[JSON::Field(key: "type")]
+  property legend_type : String?
+
+  # Explicitly set the visible legend values.
+  property values : Array(LegendValue)?
+
+  # A non-positive integer indicating z-index of the legend.
+  # If zindex is 0, legend should be drawn behind all chart elements.
+  # To put them in front, use zindex = 1.
+  property zindex : Float64?
+end
+
+# An object defining properties of the channel's scale, which is the function that
+# transforms values in the data domain (numbers, dates, strings, etc) to visual values
+# (pixels, colors, sizes) of the encoding channels.
+#
+# __Default value:__ If undefined, default [scale properties](scale.html) are applied.
+class Scale
+  include JSON::Serializable
+
+  # The logarithm base of the `log` scale (default `10`).
+  property base : Float64?
+
+  # If `true`, values that exceed the data domain are clamped to either the minimum or
+  # maximum range value
+  #
+  # __Default value:__ derived from the [scale config](config.html#scale-config)'s `clamp`
+  # (`true` by default).
+  property clamp : Bool?
+
+  # Customized domain values.
+  #
+  # For _quantitative_ fields, `domain` can take the form of a two-element array with minimum
+  # and maximum values.  [Piecewise scales](scale.html#piecewise) can be created by providing
+  # a `domain` with more than two entries.
+  # If the input field is aggregated, `domain` can also be a string value `"unaggregated"`,
+  # indicating that the domain should include the raw data values prior to the aggregation.
+  #
+  # For _temporal_ fields, `domain` can be a two-element array minimum and maximum values, in
+  # the form of either timestamps or the [DateTime definition objects](types.html#datetime).
+  #
+  # For _ordinal_ and _nominal_ fields, `domain` can be an array that lists valid input
+  # values.
+  #
+  # The `selection` property can be used to [interactively
+  # determine](selection.html#scale-domains) the scale domain.
+  property domain : DomainUnion?
+
+  # The exponent of the `pow` scale.
+  property exponent : Float64?
+
+  # The interpolation method for range values. By default, a general interpolator for
+  # numbers, dates, strings and colors (in RGB space) is used. For color ranges, this
+  # property allows interpolation in alternative color spaces. Legal values include `rgb`,
+  # `hsl`, `hsl-long`, `lab`, `hcl`, `hcl-long`, `cubehelix` and `cubehelix-long` ('-long'
+  # variants use longer paths in polar coordinate spaces). If object-valued, this property
+  # accepts an object with a string-valued _type_ property and an optional numeric _gamma_
+  # property applicable to rgb and cubehelix interpolators. For more, see the [d3-interpolate
+  # documentation](https://github.com/d3/d3-interpolate).
+  #
+  # __Note:__ Sequential scales do not support `interpolate` as they have a fixed
+  # interpolator.  Since Vega-Lite uses sequential scales for quantitative fields by default,
+  # you have to set the scale `type` to other quantitative scale type such as `"linear"` to
+  # customize `interpolate`.
+  property interpolate : InterpolateUnion?
+
+  # Extending the domain so that it starts and ends on nice round values. This method
+  # typically modifies the scale’s domain, and may only extend the bounds to the nearest
+  # round value. Nicing is useful if the domain is computed from data and may be irregular.
+  # For example, for a domain of _[0.201479…, 0.996679…]_, a nice domain might be _[0.2,
+  # 1.0]_.
+  #
+  # For quantitative scales such as linear, `nice` can be either a boolean flag or a number.
+  # If `nice` is a number, it will represent a desired tick count. This allows greater
+  # control over the step size used to extend the bounds, guaranteeing that the returned
+  # ticks will exactly cover the domain.
+  #
+  # For temporal fields with time and utc scales, the `nice` value can be a string indicating
+  # the desired time interval. Legal values are `"millisecond"`, `"second"`, `"minute"`,
+  # `"hour"`, `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, `time` and `utc`
+  # scales can accept an object-valued interval specifier of the form `{"interval": "month",
+  # "step": 3}`, which includes a desired number of interval steps. Here, the domain would
+  # snap to quarter (Jan, Apr, Jul, Oct) boundaries.
+  #
+  # __Default value:__ `true` for unbinned _quantitative_ fields; `false` otherwise.
+  property nice : NiceUnion?
+
+  # For _[continuous](scale.html#continuous)_ scales, expands the scale domain to accommodate
+  # the specified number of pixels on each of the scale range. The scale range must represent
+  # pixels for this parameter to function as intended. Padding adjustment is performed prior
+  # to all other adjustments, including the effects of the zero, nice, domainMin, and
+  # domainMax properties.
+  #
+  # For _[band](scale.html#band)_ scales, shortcut for setting `paddingInner` and
+  # `paddingOuter` to the same value.
+  #
+  # For _[point](scale.html#point)_ scales, alias for `paddingOuter`.
+  #
+  # __Default value:__ For _continuous_ scales, derived from the [scale
+  # config](scale.html#config)'s `continuousPadding`.
+  # For _band and point_ scales, see `paddingInner` and `paddingOuter`.
+  property padding : Float64?
+
+  # The inner padding (spacing) within each band step of band scales, as a fraction of the
+  # step size. This value must lie in the range [0,1].
+  #
+  # For point scale, this property is invalid as point scales do not have internal band
+  # widths (only step sizes between bands).
+  #
+  # __Default value:__ derived from the [scale config](scale.html#config)'s
+  # `bandPaddingInner`.
+  @[JSON::Field(key: "paddingInner")]
+  property padding_inner : Float64?
+
+  # The outer padding (spacing) at the ends of the range of band and point scales,
+  # as a fraction of the step size. This value must lie in the range [0,1].
+  #
+  # __Default value:__ derived from the [scale config](scale.html#config)'s
+  # `bandPaddingOuter` for band scales and `pointPadding` for point scales.
+  @[JSON::Field(key: "paddingOuter")]
+  property padding_outer : Float64?
+
+  # The range of the scale. One of:
+  #
+  # - A string indicating a [pre-defined named scale range](scale.html#range-config) (e.g.,
+  # example, `"symbol"`, or `"diverging"`).
+  #
+  # - For [continuous scales](scale.html#continuous), two-element array indicating  minimum
+  # and maximum values, or an array with more than two entries for specifying a [piecewise
+  # scale](scale.html#piecewise).
+  #
+  # - For [discrete](scale.html#discrete) and [discretizing](scale.html#discretizing) scales,
+  # an array of desired output values.
+  #
+  # __Notes:__
+  #
+  # 1) For [sequential](scale.html#sequential), [ordinal](scale.html#ordinal), and
+  # discretizing color scales, you can also specify a color [`scheme`](scale.html#scheme)
+  # instead of `range`.
+  #
+  # 2) Any directly specified `range` for `x` and `y` channels will be ignored. Range can be
+  # customized via the view's corresponding [size](size.html) (`width` and `height`) or via
+  # [range steps and paddings properties](#range-step) for [band](#band) and [point](#point)
+  # scales.
+  property range : ScaleRange?
+
+  # The distance between the starts of adjacent bands or points in [band](scale.html#band)
+  # and [point](scale.html#point) scales.
+  #
+  # If `rangeStep` is `null` or if the view contains the scale's corresponding
+  # [size](size.html) (`width` for `x` scales and `height` for `y` scales), `rangeStep` will
+  # be automatically determined to fit the size of the view.
+  #
+  # __Default value:__  derived the [scale config](config.html#scale-config)'s
+  # `textXRangeStep` (`90` by default) for x-scales of `text` marks and `rangeStep` (`21` by
+  # default) for x-scales of other marks and y-scales.
+  #
+  # __Warning__: If `rangeStep` is `null` and the cardinality of the scale's domain is higher
+  # than `width` or `height`, the rangeStep might become less than one pixel and the mark
+  # might not appear correctly.
+  @[JSON::Field(key: "rangeStep")]
+  property range_step : Float64?
+
+  # If `true`, rounds numeric output values to integers. This can be helpful for snapping to
+  # the pixel grid.
+  #
+  # __Default value:__ `false`.
+  property round : Bool?
+
+  # A string indicating a color [scheme](scale.html#scheme) name (e.g., `"category10"` or
+  # `"viridis"`) or a [scheme parameter object](scale.html#scheme-params).
+  #
+  # Discrete color schemes may be used with [discrete](scale.html#discrete) or
+  # [discretizing](scale.html#discretizing) scales. Continuous color schemes are intended for
+  # use with [sequential](scales.html#sequential) scales.
+  #
+  # For the full list of supported scheme, please refer to the [Vega
+  # Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
+  property scheme : Scheme?
+
+  # The type of scale.  Vega-Lite supports the following categories of scale types:
+  #
+  # 1) [**Continuous Scales**](scale.html#continuous) -- mapping continuous domains to
+  # continuous output ranges ([`"linear"`](scale.html#linear), [`"pow"`](scale.html#pow),
+  # [`"sqrt"`](scale.html#sqrt), [`"log"`](scale.html#log), [`"time"`](scale.html#time),
+  # [`"utc"`](scale.html#utc), [`"sequential"`](scale.html#sequential)).
+  #
+  # 2) [**Discrete Scales**](scale.html#discrete) -- mapping discrete domains to discrete
+  # ([`"ordinal"`](scale.html#ordinal)) or continuous ([`"band"`](scale.html#band) and
+  # [`"point"`](scale.html#point)) output ranges.
+  #
+  # 3) [**Discretizing Scales**](scale.html#discretizing) -- mapping continuous domains to
+  # discrete output ranges ([`"bin-linear"`](scale.html#bin-linear) and
+  # [`"bin-ordinal"`](scale.html#bin-ordinal)).
+  #
+  # __Default value:__ please see the [scale type table](scale.html#type).
+  @[JSON::Field(key: "type")]
+  property scale_type : String?
+
+  # If `true`, ensures that a zero baseline value is included in the scale domain.
+  #
+  # __Default value:__ `true` for x and y channels if the quantitative field is not binned
+  # and no custom `domain` is provided; `false` otherwise.
+  #
+  # __Note:__ Log, time, and utc scales do not support `zero`.
+  property zero : Bool?
+end
+
+class DomainClass
+  include JSON::Serializable
+
+  # The field name to extract selected values for, when a selection is
+  # [projected](project.html)
+  # over multiple fields or encodings.
+  property field : String?
+
+  # The name of a selection.
+  property selection : String
+
+  # The encoding channel to extract selected values for, when a selection is
+  # [projected](project.html)
+  # over multiple fields or encodings.
+  property encoding : String?
+end
+
+class InterpolateParams
+  include JSON::Serializable
+
+  property gamma : Float64?
+
+  @[JSON::Field(key: "type")]
+  property interpolate_params_type : String
+end
+
+class NiceClass
+  include JSON::Serializable
+
+  property interval : String
+
+  property step : Float64
+end
+
+class SchemeParams
+  include JSON::Serializable
+
+  # For sequential and diverging schemes only, determines the extent of the color range to
+  # use. For example `[0.2, 1]` will rescale the color scheme such that color values in the
+  # range _[0, 0.2)_ are excluded from the scheme.
+  property extent : Array(Float64)?
+
+  # A color scheme name for sequential/ordinal scales (e.g., `"category10"` or `"viridis"`).
+  #
+  # For the full list of supported scheme, please refer to the [Vega
+  # Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
+  property name : String
+end
+
+class SortField
+  include JSON::Serializable
+
+  # The data [field](field.html) to sort by.
+  #
+  # __Default value:__ If unspecified, defaults to the field specified in the outer data
+  # reference.
+  property field : Field?
+
+  # An [aggregate operation](aggregate.html#ops) to perform on the field prior to sorting
+  # (e.g., `"count"`, `"mean"` and `"median"`).
+  # This property is required in cases where the sort field and the data reference field do
+  # not match.
+  # The input data objects will be aggregated, grouped by the encoded data field.
+  #
+  # For a full list of operations, please see the documentation for
+  # [aggregate](aggregate.html#ops).
+  property op : String
+
+  # The sort order. One of `"ascending"` (default) or `"descending"`.
+  property order : String?
+end
+
+# Horizontal facets for trellis plots.
+#
+# Vertical facets for trellis plots.
+class FacetFieldDef
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # An object defining properties of a facet's header.
+  property header : Header?
+
+  # Sort order for a facet field.
+  # This can be `"ascending"`, `"descending"`.
+  property sort : String?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property facet_field_def_type : String
+end
+
+# An object defining properties of a facet's header.
+#
+# Headers of row / column channels for faceted plots.
+class Header
+  include JSON::Serializable
+
+  # The formatting pattern for labels. This is D3's [number format
+  # pattern](https://github.com/d3/d3-format#locale_format) for quantitative fields and D3's
+  # [time format pattern](https://github.com/d3/d3-time-format#locale_format) for time
+  # field.
+  #
+  # See the [format documentation](format.html) for more information.
+  #
+  # __Default value:__  derived from [numberFormat](config.html#format) config for
+  # quantitative fields and from [timeFormat](config.html#format) config for temporal fields.
+  property format : String?
+
+  # The rotation angle of the header labels.
+  #
+  # __Default value:__ `0`.
+  @[JSON::Field(key: "labelAngle")]
+  property label_angle : Float64?
+
+  # A title for the field. If `null`, the title will be removed.
+  #
+  # __Default value:__  derived from the field's name and transformation function
+  # (`aggregate`, `bin` and `timeUnit`).  If the field has an aggregate function, the
+  # function is displayed as a part of the title (e.g., `"Sum of Profit"`). If the field is
+  # binned or has a time unit applied, the applied function will be denoted in parentheses
+  # (e.g., `"Profit (binned)"`, `"Transaction Date (year-month)"`).  Otherwise, the title is
+  # simply the field name.
+  #
+  # __Note__: You can customize the default field title format by providing the [`fieldTitle`
+  # property in the [config](config.html) or [`fieldTitle` function via the `compile`
+  # function's options](compile.html#field-title).
+  property title : String?
+end
+
+# Definition object for a data field, its type and transformation of an encoding channel.
+class FieldDef
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property field_def_type : String
+end
+
+# A URL to load upon mouse click.
+#
+# A FieldDef with Condition<ValueDef>
+# {
+# condition: {value: ...},
+# field: ...,
+# ...
+# }
+#
+# A ValueDef with Condition<ValueDef | FieldDef>
+# {
+# condition: {field: ...} | {value: ...},
+# value: ...,
+# }
+class DefWithCondition
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # One or more value definition(s) with a selection predicate.
+  #
+  # __Note:__ A field definition's `condition` property can only contain [value
+  # definitions](encoding.html#value-def)
+  # since Vega-Lite only allows at most one encoded field per encoding channel.
+  #
+  # A field definition or one or more value definition(s) with a selection predicate.
+  property condition : HrefCondition?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property def_with_condition_type : String?
+
+  # A constant value in visual domain.
+  property value : ConditionalPredicateValueDefValue?
+end
+
+class ConditionalPredicateFieldDefClass
+  include JSON::Serializable
+
+  property test : ConditionalValueDefLogicalOperandPredicate?
+
+  # A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+  # `0` to `1` for opacity).
+  property value : ConditionalPredicateValueDefValue?
+
+  # A [selection name](selection.html), or a series of [composed
+  # selections](selection.html#compose).
+  property selection : ConditionalValueDefSelectionOperand?
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property conditional_def_type : String?
+end
+
+class OrderFieldDef
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # The sort order. One of `"ascending"` (default) or `"descending"`.
+  property sort : String?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property order_field_def_type : String
+end
+
+# Text of the `text` mark.
+#
+# The tooltip text to show upon mouse hover.
+#
+# A FieldDef with Condition<ValueDef>
+# {
+# condition: {value: ...},
+# field: ...,
+# ...
+# }
+#
+# A ValueDef with Condition<ValueDef | FieldDef>
+# {
+# condition: {field: ...} | {value: ...},
+# value: ...,
+# }
+class TextDefWithCondition
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # One or more value definition(s) with a selection predicate.
+  #
+  # __Note:__ A field definition's `condition` property can only contain [value
+  # definitions](encoding.html#value-def)
+  # since Vega-Lite only allows at most one encoded field per encoding channel.
+  #
+  # A field definition or one or more value definition(s) with a selection predicate.
+  property condition : TextCondition?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # The [formatting pattern](format.html) for a text field. If not defined, this will be
+  # determined automatically.
+  property format : String?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property text_def_with_condition_type : String?
+
+  # A constant value in visual domain.
+  property value : ConditionalPredicateValueDefValue?
+end
+
+class ConditionalPredicateTextFieldDefClass
+  include JSON::Serializable
+
+  property test : ConditionalValueDefLogicalOperandPredicate?
+
+  # A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+  # `0` to `1` for opacity).
+  property value : ConditionalPredicateValueDefValue?
+
+  # A [selection name](selection.html), or a series of [composed
+  # selections](selection.html#compose).
+  property selection : ConditionalValueDefSelectionOperand?
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # The [formatting pattern](format.html) for a text field. If not defined, this will be
+  # determined automatically.
+  property format : String?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property conditional_def_type : String?
+end
+
+# X coordinates of the marks, or width of horizontal `"bar"` and `"area"`.
+#
+# Y coordinates of the marks, or height of vertical `"bar"` and `"area"`.
+#
+# Definition object for a constant value of an encoding channel.
+class XClass
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # An object defining properties of axis's gridlines, ticks and labels.
+  # If `null`, the axis for the encoding channel will be removed.
+  #
+  # __Default value:__ If undefined, default [axis properties](axis.html) are applied.
+  property axis : Axis?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # An object defining properties of the channel's scale, which is the function that
+  # transforms values in the data domain (numbers, dates, strings, etc) to visual values
+  # (pixels, colors, sizes) of the encoding channels.
+  #
+  # __Default value:__ If undefined, default [scale properties](scale.html) are applied.
+  property scale : Scale?
+
+  # Sort order for the encoded field.
+  # Supported `sort` values include `"ascending"`, `"descending"` and `null` (no sorting).
+  # For fields with discrete domains, `sort` can also be a [sort field definition
+  # object](sort.html#sort-field).
+  #
+  # __Default value:__ `"ascending"`
+  property sort : SortUnion?
+
+  # Type of stacking offset if the field should be stacked.
+  # `stack` is only applicable for `x` and `y` channels with continuous domains.
+  # For example, `stack` of `y` can be used to customize stacking for a vertical bar chart.
+  #
+  # `stack` can be one of the following values:
+  #
+  # - `"zero"`: stacking with baseline offset at zero value of the scale (for creating
+  # typical stacked [bar](stack.html#bar) and [area](stack.html#area) chart).
+  # - `"normalize"` - stacking with normalized domain (for creating [normalized stacked bar
+  # and area charts](stack.html#normalized). <br/>
+  # - `"center"` - stacking with center baseline (for [streamgraph](stack.html#streamgraph)).
+  # - `null` - No-stacking. This will produce layered [bar](stack.html#layered-bar-chart) and
+  # area chart.
+  #
+  # __Default value:__ `zero` for plots with all of the following conditions are true:
+  #
+  # 1. The mark is `bar` or `area`;
+  # 2. The stacked measure channel (x or y) has a linear scale;
+  # 3. At least one of non-position channels mapped to an unaggregated field that is
+  # different from x and y.  Otherwise, `null` by default.
+  property stack : String?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property def_type : String?
+
+  # A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+  # `0` to `1` for opacity).
+  property value : ConditionalPredicateValueDefValue?
+end
+
+class Axis
+  include JSON::Serializable
+
+  # A boolean flag indicating if the domain (the axis baseline) should be included as part of
+  # the axis.
+  #
+  # __Default value:__ `true`
+  property domain : Bool?
+
+  # The formatting pattern for labels. This is D3's [number format
+  # pattern](https://github.com/d3/d3-format#locale_format) for quantitative fields and D3's
+  # [time format pattern](https://github.com/d3/d3-time-format#locale_format) for time
+  # field.
+  #
+  # See the [format documentation](format.html) for more information.
+  #
+  # __Default value:__  derived from [numberFormat](config.html#format) config for
+  # quantitative fields and from [timeFormat](config.html#format) config for temporal fields.
+  property format : String?
+
+  # A boolean flag indicating if grid lines should be included as part of the axis
+  #
+  # __Default value:__ `true` for [continuous scales](scale.html#continuous) that are not
+  # binned; otherwise, `false`.
+  property grid : Bool?
+
+  # The rotation angle of the axis labels.
+  #
+  # __Default value:__ `-90` for nominal and ordinal fields; `0` otherwise.
+  @[JSON::Field(key: "labelAngle")]
+  property label_angle : Float64?
+
+  # Indicates if labels should be hidden if they exceed the axis range. If `false `(the
+  # default) no bounds overlap analysis is performed. If `true`, labels will be hidden if
+  # they exceed the axis range by more than 1 pixel. If this property is a number, it
+  # specifies the pixel tolerance: the maximum amount by which a label bounding box may
+  # exceed the axis range.
+  #
+  # __Default value:__ `false`.
+  @[JSON::Field(key: "labelBound")]
+  property label_bound : Label?
+
+  # Indicates if the first and last axis labels should be aligned flush with the scale range.
+  # Flush alignment for a horizontal axis will left-align the first label and right-align the
+  # last label. For vertical axes, bottom and top text baselines are applied instead. If this
+  # property is a number, it also indicates the number of pixels by which to offset the first
+  # and last labels; for example, a value of 2 will flush-align the first and last labels and
+  # also push them 2 pixels outward from the center of the axis. The additional adjustment
+  # can sometimes help the labels better visually group with corresponding axis ticks.
+  #
+  # __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
+  @[JSON::Field(key: "labelFlush")]
+  property label_flush : Label?
+
+  # The strategy to use for resolving overlap of axis labels. If `false` (the default), no
+  # overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
+  # every other label is used (this works well for standard linear axes). If set to
+  # `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
+  # with the last visible label (this often works better for log-scaled axes).
+  #
+  # __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
+  # scales; otherwise `false`.
+  @[JSON::Field(key: "labelOverlap")]
+  property label_overlap : LabelOverlapUnion?
+
+  # The padding, in pixels, between axis and text labels.
+  @[JSON::Field(key: "labelPadding")]
+  property label_padding : Float64?
+
+  # A boolean flag indicating if labels should be included as part of the axis.
+  #
+  # __Default value:__  `true`.
+  property labels : Bool?
+
+  # The maximum extent in pixels that axis ticks and labels should use. This determines a
+  # maximum offset value for axis titles.
+  #
+  # __Default value:__ `undefined`.
+  @[JSON::Field(key: "maxExtent")]
+  property max_extent : Float64?
+
+  # The minimum extent in pixels that axis ticks and labels should use. This determines a
+  # minimum offset value for axis titles.
+  #
+  # __Default value:__ `30` for y-axis; `undefined` for x-axis.
+  @[JSON::Field(key: "minExtent")]
+  property min_extent : Float64?
+
+  # The offset, in pixels, by which to displace the axis from the edge of the enclosing group
+  # or data rectangle.
+  #
+  # __Default value:__ derived from the [axis config](config.html#facet-scale-config)'s
+  # `offset` (`0` by default)
+  property offset : Float64?
+
+  # The orientation of the axis. One of `"top"`, `"bottom"`, `"left"` or `"right"`. The
+  # orientation can be used to further specialize the axis type (e.g., a y axis oriented for
+  # the right edge of the chart).
+  #
+  # __Default value:__ `"bottom"` for x-axes and `"left"` for y-axes.
+  property orient : String?
+
+  # The anchor position of the axis in pixels. For x-axis with top or bottom orientation,
+  # this sets the axis group x coordinate. For y-axis with left or right orientation, this
+  # sets the axis group y coordinate.
+  #
+  # __Default value__: `0`
+  property position : Float64?
+
+  # A desired number of ticks, for axes visualizing quantitative scales. The resulting number
+  # may be different so that values are "nice" (multiples of 2, 5, 10) and lie within the
+  # underlying scale's range.
+  @[JSON::Field(key: "tickCount")]
+  property tick_count : Float64?
+
+  # Boolean value that determines whether the axis should include ticks.
+  property ticks : Bool?
+
+  # The size in pixels of axis ticks.
+  @[JSON::Field(key: "tickSize")]
+  property tick_size : Float64?
+
+  # A title for the field. If `null`, the title will be removed.
+  #
+  # __Default value:__  derived from the field's name and transformation function
+  # (`aggregate`, `bin` and `timeUnit`).  If the field has an aggregate function, the
+  # function is displayed as a part of the title (e.g., `"Sum of Profit"`). If the field is
+  # binned or has a time unit applied, the applied function will be denoted in parentheses
+  # (e.g., `"Profit (binned)"`, `"Transaction Date (year-month)"`).  Otherwise, the title is
+  # simply the field name.
+  #
+  # __Note__: You can customize the default field title format by providing the [`fieldTitle`
+  # property in the [config](config.html) or [`fieldTitle` function via the `compile`
+  # function's options](compile.html#field-title).
+  property title : String?
+
+  # Max length for axis title if the title is automatically generated from the field's
+  # description.
+  @[JSON::Field(key: "titleMaxLength")]
+  property title_max_length : Float64?
+
+  # The padding, in pixels, between title and axis.
+  @[JSON::Field(key: "titlePadding")]
+  property title_padding : Float64?
+
+  # Explicitly set the visible axis tick values.
+  property values : Array(AxisValue)?
+
+  # A non-positive integer indicating z-index of the axis.
+  # If zindex is 0, axes should be drawn behind all chart elements.
+  # To put them in front, use `"zindex = 1"`.
+  #
+  # __Default value:__ `1` (in front of the marks) for actual axis and `0` (behind the marks)
+  # for grids.
+  property zindex : Float64?
+end
+
+# X2 coordinates for ranged  `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
+#
+# Y2 coordinates for ranged  `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
+#
+# Definition object for a data field, its type and transformation of an encoding channel.
+#
+# Definition object for a constant value of an encoding channel.
+class X2Class
+  include JSON::Serializable
+
+  # Aggregation function for the field
+  # (e.g., `mean`, `sum`, `median`, `min`, `max`, `count`).
+  #
+  # __Default value:__ `undefined` (None)
+  property aggregate : String?
+
+  # A flag for binning a `quantitative` field, or [an object defining binning
+  # parameters](bin.html#params).
+  # If `true`, default [binning parameters](bin.html) will be applied.
+  #
+  # __Default value:__ `false`
+  property bin : Bin?
+
+  # __Required.__ A string defining the name of the field from which to pull a data value
+  # or an object defining iterated values from the [`repeat`](repeat.html) operator.
+  #
+  # __Note:__ Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
+  # (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`).
+  # If field names contain dots or brackets but are not nested, you can use `\\` to escape
+  # dots and brackets (e.g., `"a\\.b"` and `"a\\[0\\]"`).
+  # See more details about escaping in the [field documentation](field.html).
+  #
+  # __Note:__ `field` is not required if `aggregate` is `count`.
+  property field : Field?
+
+  # Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field.
+  # or [a temporal field that gets casted as ordinal](type.html#cast).
+  #
+  # __Default value:__ `undefined` (None)
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # The encoded field's type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or
+  # `"nominal"`).
+  # It can also be a geo type (`"latitude"`, `"longitude"`, and `"geojson"`) when a
+  # [geographic projection](projection.html) is applied.
+  @[JSON::Field(key: "type")]
+  property def_type : String?
+
+  # A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+  # `0` to `1` for opacity).
+  property value : ConditionalPredicateValueDefValue?
+end
+
+# An object that describes mappings between `row` and `column` channels and their field
+# definitions.
+class FacetMapping
+  include JSON::Serializable
+
+  # Horizontal facets for trellis plots.
+  property column : FacetFieldDef?
+
+  # Vertical facets for trellis plots.
+  property row : FacetFieldDef?
+end
+
+# Unit spec that can have a composite mark.
+class SpecElement
+  include JSON::Serializable
+
+  # An object describing the data source
+  property data : Data?
+
+  # Description of this mark for commenting purpose.
+  property description : String?
+
+  # The height of a visualization.
+  #
+  # __Default value:__
+  # - If a view's [`autosize`](size.html#autosize) type is `"fit"` or its y-channel has a
+  # [continuous scale](scale.html#continuous), the height will be the value of
+  # [`config.view.height`](spec.html#config).
+  # - For y-axis with a band or point scale: if [`rangeStep`](scale.html#band) is a numeric
+  # value or unspecified, the height is [determined by the range step, paddings, and the
+  # cardinality of the field mapped to y-channel](scale.html#band). Otherwise, if the
+  # `rangeStep` is `null`, the height will be the value of
+  # [`config.view.height`](spec.html#config).
+  # - If no field is mapped to `y` channel, the `height` will be the value of `rangeStep`.
+  #
+  # __Note__: For plots with [`row` and `column` channels](encoding.html#facet), this
+  # represents the height of a single view.
+  #
+  # __See also:__ The documentation for [width and height](size.html) contains more examples.
+  property height : Float64?
+
+  # Layer or single view specifications to be layered.
+  #
+  # __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
+  # layering facet specifications is not allowed.
+  property layer : Array(LayerSpec)?
+
+  # Name of the visualization for later reference.
+  property name : String?
+
+  # Scale, axis, and legend resolutions for layers.
+  #
+  # Scale, axis, and legend resolutions for facets.
+  #
+  # Scale and legend resolutions for repeated charts.
+  #
+  # Scale, axis, and legend resolutions for vertically concatenated charts.
+  #
+  # Scale, axis, and legend resolutions for horizontally concatenated charts.
+  property resolve : Resolve?
+
+  # Title for the plot.
+  property title : Title?
+
+  # An array of data transformations such as filter and new field calculation.
+  property transform : Array(Transform)?
+
+  # The width of a visualization.
+  #
+  # __Default value:__ This will be determined by the following rules:
+  #
+  # - If a view's [`autosize`](size.html#autosize) type is `"fit"` or its x-channel has a
+  # [continuous scale](scale.html#continuous), the width will be the value of
+  # [`config.view.width`](spec.html#config).
+  # - For x-axis with a band or point scale: if [`rangeStep`](scale.html#band) is a numeric
+  # value or unspecified, the width is [determined by the range step, paddings, and the
+  # cardinality of the field mapped to x-channel](scale.html#band).   Otherwise, if the
+  # `rangeStep` is `null`, the width will be the value of
+  # [`config.view.width`](spec.html#config).
+  # - If no field is mapped to `x` channel, the `width` will be the value of
+  # [`config.scale.textXRangeStep`](size.html#default-width-and-height) for `text` mark and
+  # the value of `rangeStep` for other marks.
+  #
+  # __Note:__ For plots with [`row` and `column` channels](encoding.html#facet), this
+  # represents the width of a single view.
+  #
+  # __See also:__ The documentation for [width and height](size.html) contains more examples.
+  property width : Float64?
+
+  # A key-value mapping between encoding channels and definition of fields.
+  property encoding : Encoding?
+
+  # A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
+  # `"line"`,
+  # * `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark definition
+  # object](mark.html#mark-def).
+  property mark : AnyMark?
+
+  # An object defining properties of geographic projection.
+  #
+  # Works with `"geoshape"` marks and `"point"` or `"line"` marks that have a channel (one or
+  # more of `"X"`, `"X2"`, `"Y"`, `"Y2"`) with type `"latitude"`, or `"longitude"`.
+  property projection : Projection?
+
+  # A key-value mapping between selection names and definitions.
+  property selection : Hash(String, SelectionDef)?
+
+  # An object that describes mappings between `row` and `column` channels and their field
+  # definitions.
+  property facet : FacetMapping?
+
+  # A specification of the view that gets faceted.
+  property spec : SpecElement?
+
+  # An object that describes what fields should be repeated into views that are laid out as a
+  # `row` or `column`.
+  property repeat : Repeat?
+
+  # A list of views that should be concatenated and put into a column.
+  property vconcat : Array(SpecElement)?
+
+  # A list of views that should be concatenated and put into a row.
+  property hconcat : Array(SpecElement)?
+end
+
+# A key-value mapping between encoding channels and definition of fields.
+class Encoding
+  include JSON::Serializable
+
+  # Color of the marks – either fill or stroke color based on mark type.
+  # By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
+  # `"text"`, `"circle"`, and `"square"` / stroke color for `"line"` and `"point"`.
+  #
+  # __Default value:__ If undefined, the default color depends on [mark
+  # config](config.html#mark)'s `color` property.
+  #
+  # _Note:_ See the scale documentation for more information about customizing [color
+  # scheme](scale.html#scheme).
+  property color : MarkPropDefWithCondition?
+
+  # Additional levels of detail for grouping data in aggregate views and
+  # in line and area marks without mapping data to a specific visual channel.
+  property detail : Detail?
+
+  # A URL to load upon mouse click.
+  property href : DefWithCondition?
+
+  # Opacity of the marks – either can be a value or a range.
+  #
+  # __Default value:__ If undefined, the default opacity depends on [mark
+  # config](config.html#mark)'s `opacity` property.
+  property opacity : MarkPropDefWithCondition?
+
+  # Stack order for stacked marks or order of data points in line marks for connected scatter
+  # plots.
+  #
+  # __Note__: In aggregate plots, `order` field should be `aggregate`d to avoid creating
+  # additional aggregation grouping.
+  property order : Order?
+
+  # For `point` marks the supported values are
+  # `"circle"` (default), `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`,
+  # or `"triangle-down"`, or else a custom SVG path string.
+  # For `geoshape` marks it should be a field definition of the geojson data
+  #
+  # __Default value:__ If undefined, the default shape depends on [mark
+  # config](config.html#point-config)'s `shape` property.
+  property shape : MarkPropDefWithCondition?
+
+  # Size of the mark.
+  # - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
+  # - For `"bar"` and `"tick"` – the bar and tick's size.
+  # - For `"text"` – the text's font size.
+  # - Size is currently unsupported for `"line"`, `"area"`, and `"rect"`.
+  property size : MarkPropDefWithCondition?
+
+  # Text of the `text` mark.
+  property text : TextDefWithCondition?
+
+  # The tooltip text to show upon mouse hover.
+  property tooltip : TextDefWithCondition?
+
+  # X coordinates of the marks, or width of horizontal `"bar"` and `"area"`.
+  property x : XClass?
+
+  # X2 coordinates for ranged  `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
+  property x2 : X2Class?
+
+  # Y coordinates of the marks, or height of vertical `"bar"` and `"area"`.
+  property y : XClass?
+
+  # Y2 coordinates for ranged  `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
+  property y2 : X2Class?
+end
+
+# Unit spec that can have a composite mark.
+class LayerSpec
+  include JSON::Serializable
+
+  # An object describing the data source
+  property data : Data?
+
+  # Description of this mark for commenting purpose.
+  property description : String?
+
+  # The height of a visualization.
+  #
+  # __Default value:__
+  # - If a view's [`autosize`](size.html#autosize) type is `"fit"` or its y-channel has a
+  # [continuous scale](scale.html#continuous), the height will be the value of
+  # [`config.view.height`](spec.html#config).
+  # - For y-axis with a band or point scale: if [`rangeStep`](scale.html#band) is a numeric
+  # value or unspecified, the height is [determined by the range step, paddings, and the
+  # cardinality of the field mapped to y-channel](scale.html#band). Otherwise, if the
+  # `rangeStep` is `null`, the height will be the value of
+  # [`config.view.height`](spec.html#config).
+  # - If no field is mapped to `y` channel, the `height` will be the value of `rangeStep`.
+  #
+  # __Note__: For plots with [`row` and `column` channels](encoding.html#facet), this
+  # represents the height of a single view.
+  #
+  # __See also:__ The documentation for [width and height](size.html) contains more examples.
+  property height : Float64?
+
+  # Layer or single view specifications to be layered.
+  #
+  # __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
+  # layering facet specifications is not allowed.
+  property layer : Array(LayerSpec)?
+
+  # Name of the visualization for later reference.
+  property name : String?
+
+  # Scale, axis, and legend resolutions for layers.
+  property resolve : Resolve?
+
+  # Title for the plot.
+  property title : Title?
+
+  # An array of data transformations such as filter and new field calculation.
+  property transform : Array(Transform)?
+
+  # The width of a visualization.
+  #
+  # __Default value:__ This will be determined by the following rules:
+  #
+  # - If a view's [`autosize`](size.html#autosize) type is `"fit"` or its x-channel has a
+  # [continuous scale](scale.html#continuous), the width will be the value of
+  # [`config.view.width`](spec.html#config).
+  # - For x-axis with a band or point scale: if [`rangeStep`](scale.html#band) is a numeric
+  # value or unspecified, the width is [determined by the range step, paddings, and the
+  # cardinality of the field mapped to x-channel](scale.html#band).   Otherwise, if the
+  # `rangeStep` is `null`, the width will be the value of
+  # [`config.view.width`](spec.html#config).
+  # - If no field is mapped to `x` channel, the `width` will be the value of
+  # [`config.scale.textXRangeStep`](size.html#default-width-and-height) for `text` mark and
+  # the value of `rangeStep` for other marks.
+  #
+  # __Note:__ For plots with [`row` and `column` channels](encoding.html#facet), this
+  # represents the width of a single view.
+  #
+  # __See also:__ The documentation for [width and height](size.html) contains more examples.
+  property width : Float64?
+
+  # A key-value mapping between encoding channels and definition of fields.
+  property encoding : Encoding?
+
+  # A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
+  # `"line"`,
+  # * `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark definition
+  # object](mark.html#mark-def).
+  property mark : AnyMark?
+
+  # An object defining properties of geographic projection.
+  #
+  # Works with `"geoshape"` marks and `"point"` or `"line"` marks that have a channel (one or
+  # more of `"X"`, `"X2"`, `"Y"`, `"Y2"`) with type `"latitude"`, or `"longitude"`.
+  property projection : Projection?
+
+  # A key-value mapping between selection names and definitions.
+  property selection : Hash(String, SelectionDef)?
+end
+
+class MarkDef
+  include JSON::Serializable
+
+  # The horizontal alignment of the text. One of `"left"`, `"right"`, `"center"`.
+  property align : String?
+
+  # The rotation angle of the text, in degrees.
+  property angle : Float64?
+
+  # The vertical alignment of the text. One of `"top"`, `"middle"`, `"bottom"`.
+  #
+  # __Default value:__ `"middle"`
+  property baseline : String?
+
+  # Whether a mark be clipped to the enclosing group’s width and height.
+  property clip : Bool?
+
+  # Default color.  Note that `fill` and `stroke` have higher precedence than `color` and
+  # will override `color`.
+  #
+  # __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property color : String?
+
+  # The mouse cursor used over the mark. Any valid [CSS cursor
+  # type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
+  property cursor : String?
+
+  # The horizontal offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dx : Float64?
+
+  # The vertical offset, in pixels, between the text label and its anchor point. The offset
+  # is applied after rotation by the _angle_ property.
+  property dy : Float64?
+
+  # Default Fill Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property fill : String?
+
+  # Whether the mark's color should be used as fill color instead of stroke color.
+  #
+  # __Default value:__ `true` for all marks except `point` and `false` for `point`.
+  #
+  # __Applicable for:__ `bar`, `point`, `circle`, `square`, and `area` marks.
+  #
+  # __Note:__ This property cannot be used in a [style config](mark.html#style-config).
+  property filled : Bool?
+
+  # The fill opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "fillOpacity")]
+  property fill_opacity : Float64?
+
+  # The typeface to set the text in (e.g., `"Helvetica Neue"`).
+  property font : String?
+
+  # The font size, in pixels.
+  @[JSON::Field(key: "fontSize")]
+  property font_size : Float64?
+
+  # The font style (e.g., `"italic"`).
+  @[JSON::Field(key: "fontStyle")]
+  property font_style : String?
+
+  # The font weight (e.g., `"bold"`).
+  @[JSON::Field(key: "fontWeight")]
+  property font_weight : FontWeightUnion?
+
+  # A URL to load upon mouse click. If defined, the mark acts as a hyperlink.
+  property href : String?
+
+  # The line interpolation method to use for line and area marks. One of the following:
+  # - `"linear"`: piecewise linear segments, as in a polyline.
+  # - `"linear-closed"`: close the linear segments to form a polygon.
+  # - `"step"`: alternate between horizontal and vertical segments, as in a step function.
+  # - `"step-before"`: alternate between vertical and horizontal segments, as in a step
+  # function.
+  # - `"step-after"`: alternate between horizontal and vertical segments, as in a step
+  # function.
+  # - `"basis"`: a B-spline, with control point duplication on the ends.
+  # - `"basis-open"`: an open B-spline; may not intersect the start or end.
+  # - `"basis-closed"`: a closed B-spline, as in a loop.
+  # - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
+  # - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
+  # will intersect other control points.
+  # - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
+  # - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
+  # spline.
+  # - `"monotone"`: cubic interpolation that preserves monotonicity in y.
+  property interpolate : String?
+
+  # The maximum length of the text mark in pixels (default 0, indicating no limit). The text
+  # value will be automatically truncated if the rendered size exceeds the limit.
+  property limit : Float64?
+
+  # The overall opacity (value between [0,1]).
+  #
+  # __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
+  # `square` marks or layered `bar` charts and `1` otherwise.
+  property opacity : Float64?
+
+  # The orientation of a non-stacked bar, tick, area, and line charts.
+  # The value is either horizontal (default) or vertical.
+  # - For bar, rule and tick, this determines whether the size of the bar and tick
+  # should be applied to x or y dimension.
+  # - For area, this property determines the orient property of the Vega output.
+  # - For line, this property determines the sort order of the points in the line
+  # if `config.sortLineBy` is not specified.
+  # For stacked charts, this is always determined by the orientation of the stack;
+  # therefore explicitly specified value will be ignored.
+  property orient : String?
+
+  # Polar coordinate radial offset, in pixels, of the text label from the origin determined
+  # by the `x` and `y` properties.
+  property radius : Float64?
+
+  # The default symbol shape to use. One of: `"circle"` (default), `"square"`, `"cross"`,
+  # `"diamond"`, `"triangle-up"`, or `"triangle-down"`, or a custom SVG path.
+  #
+  # __Default value:__ `"circle"`
+  property shape : String?
+
+  # The pixel area each the point/circle/square.
+  # For example: in the case of circles, the radius is determined in part by the square root
+  # of the size value.
+  #
+  # __Default value:__ `30`
+  property size : Float64?
+
+  # Default Stroke Color.  This has higher precedence than config.color
+  #
+  # __Default value:__ (None)
+  property stroke : String?
+
+  # An array of alternating stroke, space lengths for creating dashed or dotted lines.
+  @[JSON::Field(key: "strokeDash")]
+  property stroke_dash : Array(Float64)?
+
+  # The offset (in pixels) into which to begin drawing with the stroke dash array.
+  @[JSON::Field(key: "strokeDashOffset")]
+  property stroke_dash_offset : Float64?
+
+  # The stroke opacity (value between [0,1]).
+  #
+  # __Default value:__ `1`
+  @[JSON::Field(key: "strokeOpacity")]
+  property stroke_opacity : Float64?
+
+  # The stroke width, in pixels.
+  @[JSON::Field(key: "strokeWidth")]
+  property stroke_width : Float64?
+
+  # A string or array of strings indicating the name of custom styles to apply to the mark. A
+  # style is a named collection of mark property defaults defined within the [style
+  # configuration](mark.html#style-config). If style is an array, later styles will override
+  # earlier styles. Any [mark properties](encoding.html#mark-prop) explicitly defined within
+  # the `encoding` will override a style default.
+  #
+  # __Default value:__ The mark's name.  For example, a bar mark will have style `"bar"` by
+  # default.
+  # __Note:__ Any specified style will augment the default style. For example, a bar mark
+  # with `"style": "foo"` will receive from `config.style.bar` and `config.style.foo` (the
+  # specified style `"foo"` has higher precedence).
+  property style : Style?
+
+  # Depending on the interpolation type, sets the tension parameter (for line and area marks).
+  property tension : Float64?
+
+  # Placeholder text if the `text` channel is not specified
+  property text : String?
+
+  # Polar coordinate angle, in radians, of the text label from the origin determined by the
+  # `x` and `y` properties. Values for `theta` follow the same convention of `arc` mark
+  # `startAngle` and `endAngle` properties: angles are measured in radians, with `0`
+  # indicating "north".
+  property theta : Float64?
+
+  # The mark type.
+  # One of `"bar"`, `"circle"`, `"square"`, `"tick"`, `"line"`,
+  # `"area"`, `"point"`, `"geoshape"`, `"rule"`, and `"text"`.
+  @[JSON::Field(key: "type")]
+  property mark_def_type : String
+end
+
+# An object defining properties of geographic projection.
+#
+# Works with `"geoshape"` marks and `"point"` or `"line"` marks that have a channel (one or
+# more of `"X"`, `"X2"`, `"Y"`, `"Y2"`) with type `"latitude"`, or `"longitude"`.
+class Projection
+  include JSON::Serializable
+
+  # Sets the projection’s center to the specified center, a two-element array of longitude
+  # and latitude in degrees.
+  #
+  # __Default value:__ `[0, 0]`
+  property center : Array(Float64)?
+
+  # Sets the projection’s clipping circle radius to the specified angle in degrees. If
+  # `null`, switches to [antimeridian](http://bl.ocks.org/mbostock/3788999) cutting rather
+  # than small-circle clipping.
+  @[JSON::Field(key: "clipAngle")]
+  property clip_angle : Float64?
+
+  # Sets the projection’s viewport clip extent to the specified bounds in pixels. The extent
+  # bounds are specified as an array `[[x0, y0], [x1, y1]]`, where `x0` is the left-side of
+  # the viewport, `y0` is the top, `x1` is the right and `y1` is the bottom. If `null`, no
+  # viewport clipping is performed.
+  @[JSON::Field(key: "clipExtent")]
+  property clip_extent : Array(Array(Float64))?
+
+  property coefficient : Float64?
+
+  property distance : Float64?
+
+  property fraction : Float64?
+
+  property lobes : Float64?
+
+  property parallel : Float64?
+
+  # Sets the threshold for the projection’s [adaptive
+  # resampling](http://bl.ocks.org/mbostock/3795544) to the specified value in pixels. This
+  # value corresponds to the [Douglas–Peucker
+  # distance](http://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm).
+  # If precision is not specified, returns the projection’s current resampling precision
+  # which defaults to `√0.5 ≅ 0.70710…`.
+  property precision : Hash(String, PrecisionValue)?
+
+  property radius : Float64?
+
+  property ratio : Float64?
+
+  # Sets the projection’s three-axis rotation to the specified angles, which must be a two-
+  # or three-element array of numbers [`lambda`, `phi`, `gamma`] specifying the rotation
+  # angles in degrees about each spherical axis. (These correspond to yaw, pitch and roll.)
+  #
+  # __Default value:__ `[0, 0, 0]`
+  property rotate : Array(Float64)?
+
+  property spacing : Float64?
+
+  property tilt : Float64?
+
+  # The cartographic projection to use. This value is case-insensitive, for example
+  # `"albers"` and `"Albers"` indicate the same projection type. You can find all valid
+  # projection types [in the
+  # documentation](https://vega.github.io/vega-lite/docs/projection.html#projection-types).
+  #
+  # __Default value:__ `mercator`
+  @[JSON::Field(key: "type")]
+  property projection_type : String?
+end
+
+# Scale, axis, and legend resolutions for layers.
+#
+# Defines how scales, axes, and legends from different specs should be combined. Resolve is
+# a mapping from `scale`, `axis`, and `legend` to a mapping from channels to resolutions.
+#
+# Scale, axis, and legend resolutions for facets.
+#
+# Scale and legend resolutions for repeated charts.
+#
+# Scale, axis, and legend resolutions for vertically concatenated charts.
+#
+# Scale, axis, and legend resolutions for horizontally concatenated charts.
+class Resolve
+  include JSON::Serializable
+
+  property axis : AxisResolveMap?
+
+  property legend : LegendResolveMap?
+
+  property scale : ScaleResolveMap?
+end
+
+class AxisResolveMap
+  include JSON::Serializable
+
+  property x : String?
+
+  property y : String?
+end
+
+class LegendResolveMap
+  include JSON::Serializable
+
+  property color : String?
+
+  property opacity : String?
+
+  property shape : String?
+
+  property size : String?
+end
+
+class ScaleResolveMap
+  include JSON::Serializable
+
+  property color : String?
+
+  property opacity : String?
+
+  property shape : String?
+
+  property size : String?
+
+  property x : String?
+
+  property y : String?
+end
+
+class SelectionDef
+  include JSON::Serializable
+
+  # Establish a two-way binding between a single selection and input elements
+  # (also known as dynamic query widgets). A binding takes the form of
+  # Vega's [input element binding definition](https://vega.github.io/vega/docs/signals/#bind)
+  # or can be a mapping between projected field/encodings and binding definitions.
+  #
+  # See the [bind transform](bind.html) documentation for more information.
+  #
+  # Establishes a two-way binding between the interval selection and the scales
+  # used within the same view. This allows a user to interactively pan and
+  # zoom the view.
+  property bind : BindUnion?
+
+  # By default, all data values are considered to lie within an empty selection.
+  # When set to `none`, empty selections contain no data values.
+  property empty : String?
+
+  # An array of encoding channels. The corresponding data field values
+  # must match for a data tuple to fall within the selection.
+  property encodings : Array(String)?
+
+  # An array of field names whose values must match for a data tuple to
+  # fall within the selection.
+  property fields : Array(String)?
+
+  # When true, an invisible voronoi diagram is computed to accelerate discrete
+  # selection. The data value _nearest_ the mouse cursor is added to the selection.
+  #
+  # See the [nearest transform](nearest.html) documentation for more information.
+  property nearest : Bool?
+
+  # A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
+  # selector) that triggers the selection.
+  # For interval selections, the event stream must specify a [start and
+  # end](https://vega.github.io/vega/docs/event-streams/#between-filters).
+  property on : JSON::Any?
+
+  # With layered and multi-view displays, a strategy that determines how
+  # selections' data queries are resolved when applied in a filter transform,
+  # conditional encoding rule, or scale domain.
+  property resolve : String?
+
+  @[JSON::Field(key: "type")]
+  property selection_def_type : String
+
+  # Controls whether data values should be toggled or only ever inserted into
+  # multi selections. Can be `true`, `false` (for insertion only), or a
+  # [Vega expression](https://vega.github.io/vega/docs/expressions/).
+  #
+  # __Default value:__ `true`, which corresponds to `event.shiftKey` (i.e.,
+  # data values are toggled when a user interacts with the shift-key pressed).
+  #
+  # See the [toggle transform](toggle.html) documentation for more information.
+  property toggle : Translate?
+
+  # An interval selection also adds a rectangle mark to depict the
+  # extents of the interval. The `mark` property can be used to customize the
+  # appearance of the mark.
+  property mark : BrushConfig?
+
+  # When truthy, allows a user to interactively move an interval selection
+  # back-and-forth. Can be `true`, `false` (to disable panning), or a
+  # [Vega event stream definition](https://vega.github.io/vega/docs/event-streams/)
+  # which must include a start and end event to trigger continuous panning.
+  #
+  # __Default value:__ `true`, which corresponds to
+  # `[mousedown, window:mouseup] > window:mousemove!` which corresponds to
+  # clicks and dragging within an interval selection to reposition it.
+  property translate : Translate?
+
+  # When truthy, allows a user to interactively resize an interval selection.
+  # Can be `true`, `false` (to disable zooming), or a [Vega event stream
+  # definition](https://vega.github.io/vega/docs/event-streams/). Currently,
+  # only `wheel` events are supported.
+  #
+  #
+  # __Default value:__ `true`, which corresponds to `wheel!`.
+  property zoom : Translate?
+end
+
+class TitleParams
+  include JSON::Serializable
+
+  # The anchor position for placing the title. One of `"start"`, `"middle"`, or `"end"`. For
+  # example, with an orientation of top these anchor positions map to a left-, center-, or
+  # right-aligned title.
+  #
+  # __Default value:__ `"middle"` for [single](spec.html) and [layered](layer.html) views.
+  # `"start"` for other composite views.
+  #
+  # __Note:__ [For now](https://github.com/vega/vega-lite/issues/2875), `anchor` is only
+  # customizable only for [single](spec.html) and [layered](layer.html) views.  For other
+  # composite views, `anchor` is always `"start"`.
+  property anchor : String?
+
+  # The orthogonal offset in pixels by which to displace the title from its position along
+  # the edge of the chart.
+  property offset : Float64?
+
+  # The orientation of the title relative to the chart. One of `"top"` (the default),
+  # `"bottom"`, `"left"`, or `"right"`.
+  property orient : String?
+
+  # A [mark style property](config.html#style) to apply to the title text mark.
+  #
+  # __Default value:__ `"group-title"`.
+  property style : Style?
+
+  # The title text.
+  property text : String
+end
+
+class Transform
+  include JSON::Serializable
+
+  # The `filter` property must be one of the predicate definitions:
+  # (1) an [expression](types.html#expression) string,
+  # where `datum` can be used to refer to the current data object;
+  # (2) one of the field predicates: [equal predicate](filter.html#equal-predicate);
+  # [range predicate](filter.html#range-predicate), [one-of
+  # predicate](filter.html#one-of-predicate);
+  # (3) a [selection predicate](filter.html#selection-predicate);
+  # or (4) a logical operand that combines (1), (2), or (3).
+  property filter : ConditionalValueDefLogicalOperandPredicate?
+
+  # The field for storing the computed formula value.
+  #
+  # The field or fields for storing the computed formula value.
+  # If `from.fields` is specified, the transform will use the same names for `as`.
+  # If `from.fields` is not specified, `as` has to be a string and we put the whole object
+  # into the data under the specified name.
+  #
+  # The output fields at which to write the start and end bin values.
+  #
+  # The output field to write the timeUnit value.
+  @[JSON::Field(key: "as")]
+  property transform_as : Style?
+
+  # A [expression](types.html#expression) string. Use the variable `datum` to refer to the
+  # current data object.
+  property calculate : String?
+
+  # The default value to use if lookup fails.
+  #
+  # __Default value:__ `null`
+  property default : String?
+
+  # Secondary data reference.
+  property from : LookupData?
+
+  # Key in primary data source.
+  property lookup : String?
+
+  # An object indicating bin properties, or simply `true` for using default bin parameters.
+  property bin : Bin?
+
+  # The data field to bin.
+  #
+  # The data field to apply time unit.
+  property field : String?
+
+  # The timeUnit.
+  @[JSON::Field(key: "timeUnit")]
+  property time_unit : String?
+
+  # Array of objects that define fields to aggregate.
+  property aggregate : Array(AggregatedFieldDef)?
+
+  # The data fields to group by. If not specified, a single group containing all data objects
+  # will be used.
+  property groupby : Array(String)?
+end
+
+class AggregatedFieldDef
+  include JSON::Serializable
+
+  # The output field names to use for each aggregated field.
+  @[JSON::Field(key: "as")]
+  property aggregated_field_def_as : String
+
+  # The data field for which to compute aggregate function.
+  property field : String
+
+  # The aggregation operations to apply to the fields, such as sum, average or count.
+  # See the [full list of supported aggregation
+  # operations](https://vega.github.io/vega-lite/docs/aggregate.html#ops)
+  # for more information.
+  property op : String
+end
+
+# Secondary data reference.
+class LookupData
+  include JSON::Serializable
+
+  # Secondary data source to lookup in.
+  property data : Data
+
+  # Fields in foreign data to lookup.
+  # If not specified, the entire object is queried.
+  property fields : Array(String)?
+
+  # Key in data to lookup.
+  property key : String
+end
+
+# An object that describes what fields should be repeated into views that are laid out as a
+# `row` or `column`.
+class Repeat
+  include JSON::Serializable
+
+  # Horizontal repeated views.
+  property column : Array(String)?
+
+  # Vertical repeated views.
+  property row : Array(String)?
+end
+
+# Sets how the visualization size should be determined. If a string, should be one of
+# `"pad"`, `"fit"` or `"none"`.
+# Object values can additionally specify parameters for content sizing and automatic
+# resizing.
+# `"fit"` is only supported for single and layered views that don't use `rangeStep`.
+#
+# __Default value__: `pad`
+alias Autosize = AutoSizeParams | String
+
+# The font weight (e.g., `"bold"`).
+#
+# Font weight for title text.
+alias FontWeightUnion = Float64 | String
+
+# Indicates if labels should be hidden if they exceed the axis range. If `false `(the
+# default) no bounds overlap analysis is performed. If `true`, labels will be hidden if
+# they exceed the axis range by more than 1 pixel. If this property is a number, it
+# specifies the pixel tolerance: the maximum amount by which a label bounding box may
+# exceed the axis range.
+#
+# __Default value:__ `false`.
+#
+# Indicates if the first and last axis labels should be aligned flush with the scale range.
+# Flush alignment for a horizontal axis will left-align the first label and right-align the
+# last label. For vertical axes, bottom and top text baselines are applied instead. If this
+# property is a number, it also indicates the number of pixels by which to offset the first
+# and last labels; for example, a value of 2 will flush-align the first and last labels and
+# also push them 2 pixels outward from the center of the axis. The additional adjustment
+# can sometimes help the labels better visually group with corresponding axis ticks.
+#
+# __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
+alias Label = Float64 | Bool
+
+alias LabelOverlapUnion = Bool | String
+
+# Font weight of the title. (e.g., `"bold"`).
+#
+# The font weight of the legend title.
+alias TitleFontWeightUnion = Float64 | String
+
+# The default visualization padding, in pixels, from the edge of the visualization canvas
+# to the data rectangle.  If a number, specifies padding for all sides.
+# If an object, the value should have the format `{"left": 5, "top": 5, "right": 5,
+# "bottom": 5}` to specify padding for each side of the visualization.
+#
+# __Default value__: `5`
+alias Padding = Float64 | PaddingClass
+
+# Font weight of the title. (e.g., `"bold"`).
+#
+# The font weight of the legend title.
+alias PrecisionValue = Float64 | String
+
+alias RangeConfigValue = Array(PrecisionValue) | VgScheme
+
+# When truthy, allows a user to interactively move an interval selection
+# back-and-forth. Can be `true`, `false` (to disable panning), or a
+# [Vega event stream definition](https://vega.github.io/vega/docs/event-streams/)
+# which must include a start and end event to trigger continuous panning.
+#
+# __Default value:__ `true`, which corresponds to
+# `[mousedown, window:mouseup] > window:mousemove!` which corresponds to
+# clicks and dragging within an interval selection to reposition it.
+#
+# When truthy, allows a user to interactively resize an interval selection.
+# Can be `true`, `false` (to disable zooming), or a [Vega event stream
+# definition](https://vega.github.io/vega/docs/event-streams/). Currently,
+# only `wheel` events are supported.
+#
+#
+# __Default value:__ `true`, which corresponds to `wheel!`.
+#
+# Controls whether data values should be toggled or only ever inserted into
+# multi selections. Can be `true`, `false` (for insertion only), or a
+# [Vega expression](https://vega.github.io/vega/docs/expressions/).
+#
+# __Default value:__ `true`, which corresponds to `event.shiftKey` (i.e.,
+# data values are toggled when a user interacts with the shift-key pressed).
+#
+# See the [toggle transform](toggle.html) documentation for more information.
+alias Translate = Bool | String
+
+alias ParseUnion = Hash(String, JSON::Any?) | String
+
+# The full data set, included inline. This can be an array of objects or primitive values
+# or a string.
+# Arrays of primitive values are ingested as objects with a `data` property. Strings are
+# parsed according to the specified format type.
+alias Values = Hash(String, JSON::Any?) | String | Array(ValuesValue)
+
+alias ValuesValue = Hash(String, JSON::Any?) | Float64 | Bool | String
+
+alias Bin = BinParams | Bool
+
+alias ColorCondition = ConditionalPredicateMarkPropFieldDefClass | Array(ConditionalValueDef)
+
+# Filter using a selection name.
+#
+# A [selection name](selection.html), or a series of [composed
+# selections](selection.html#compose).
+alias SelectionOperandElement = String | Selection
+
+# Filter using a selection name.
+#
+# A [selection name](selection.html), or a series of [composed
+# selections](selection.html#compose).
+alias ConditionalValueDefSelectionOperand = String | Selection
+
+# The `filter` property must be one of the predicate definitions:
+# (1) an [expression](types.html#expression) string,
+# where `datum` can be used to refer to the current data object;
+# (2) one of the field predicates: [equal predicate](filter.html#equal-predicate);
+# [range predicate](filter.html#range-predicate), [one-of
+# predicate](filter.html#one-of-predicate);
+# (3) a [selection predicate](filter.html#selection-predicate);
+# or (4) a logical operand that combines (1), (2), or (3).
+alias LogicalOperandPredicateElement = Predicate | String
+
+# The `filter` property must be one of the predicate definitions:
+# (1) an [expression](types.html#expression) string,
+# where `datum` can be used to refer to the current data object;
+# (2) one of the field predicates: [equal predicate](filter.html#equal-predicate);
+# [range predicate](filter.html#range-predicate), [one-of
+# predicate](filter.html#one-of-predicate);
+# (3) a [selection predicate](filter.html#selection-predicate);
+# or (4) a logical operand that combines (1), (2), or (3).
+alias ConditionalValueDefLogicalOperandPredicate = Predicate | String
+
+# The value that the field should be equal to.
+alias EqualUnion = DateTime | Float64 | Bool | String
+
+# Value representing the day of a week.  This can be one of: (1) integer value -- `1`
+# represents Monday; (2) case-insensitive day name (e.g., `"Monday"`);  (3)
+# case-insensitive, 3-character short day name (e.g., `"Mon"`).   <br/> **Warning:** A
+# DateTime definition object with `day`** should not be combined with `year`, `quarter`,
+# `month`, or `date`.
+alias Day = Float64 | String
+
+# One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
+# (2) case-insensitive month name (e.g., `"January"`);  (3) case-insensitive, 3-character
+# short month name (e.g., `"Jan"`).
+alias Month = Float64 | String
+
+# The value that the field should be equal to.
+alias OneOfElement = DateTime | Float64 | Bool | String
+
+alias RangeElement = DateTime | Float64
+
+# A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+# `0` to `1` for opacity).
+#
+# A constant value in visual domain.
+alias ConditionalValueDefValue = Float64 | Bool | String
+
+alias Field = String | RepeatRef
+
+alias LegendValue = DateTime | Float64 | String
+
+# Customized domain values.
+#
+# For _quantitative_ fields, `domain` can take the form of a two-element array with minimum
+# and maximum values.  [Piecewise scales](scale.html#piecewise) can be created by providing
+# a `domain` with more than two entries.
+# If the input field is aggregated, `domain` can also be a string value `"unaggregated"`,
+# indicating that the domain should include the raw data values prior to the aggregation.
+#
+# For _temporal_ fields, `domain` can be a two-element array minimum and maximum values, in
+# the form of either timestamps or the [DateTime definition objects](types.html#datetime).
+#
+# For _ordinal_ and _nominal_ fields, `domain` can be an array that lists valid input
+# values.
+#
+# The `selection` property can be used to [interactively
+# determine](selection.html#scale-domains) the scale domain.
+alias DomainUnion = DomainClass | String | Array(OneOfElement)
+
+# The interpolation method for range values. By default, a general interpolator for
+# numbers, dates, strings and colors (in RGB space) is used. For color ranges, this
+# property allows interpolation in alternative color spaces. Legal values include `rgb`,
+# `hsl`, `hsl-long`, `lab`, `hcl`, `hcl-long`, `cubehelix` and `cubehelix-long` ('-long'
+# variants use longer paths in polar coordinate spaces). If object-valued, this property
+# accepts an object with a string-valued _type_ property and an optional numeric _gamma_
+# property applicable to rgb and cubehelix interpolators. For more, see the [d3-interpolate
+# documentation](https://github.com/d3/d3-interpolate).
+#
+# __Note:__ Sequential scales do not support `interpolate` as they have a fixed
+# interpolator.  Since Vega-Lite uses sequential scales for quantitative fields by default,
+# you have to set the scale `type` to other quantitative scale type such as `"linear"` to
+# customize `interpolate`.
+alias InterpolateUnion = InterpolateParams | String
+
+# Extending the domain so that it starts and ends on nice round values. This method
+# typically modifies the scale’s domain, and may only extend the bounds to the nearest
+# round value. Nicing is useful if the domain is computed from data and may be irregular.
+# For example, for a domain of _[0.201479…, 0.996679…]_, a nice domain might be _[0.2,
+# 1.0]_.
+#
+# For quantitative scales such as linear, `nice` can be either a boolean flag or a number.
+# If `nice` is a number, it will represent a desired tick count. This allows greater
+# control over the step size used to extend the bounds, guaranteeing that the returned
+# ticks will exactly cover the domain.
+#
+# For temporal fields with time and utc scales, the `nice` value can be a string indicating
+# the desired time interval. Legal values are `"millisecond"`, `"second"`, `"minute"`,
+# `"hour"`, `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, `time` and `utc`
+# scales can accept an object-valued interval specifier of the form `{"interval": "month",
+# "step": 3}`, which includes a desired number of interval steps. Here, the domain would
+# snap to quarter (Jan, Apr, Jul, Oct) boundaries.
+#
+# __Default value:__ `true` for unbinned _quantitative_ fields; `false` otherwise.
+alias NiceUnion = Float64 | NiceClass | Bool | String
+
+# The range of the scale. One of:
+#
+# - A string indicating a [pre-defined named scale range](scale.html#range-config) (e.g.,
+# example, `"symbol"`, or `"diverging"`).
+#
+# - For [continuous scales](scale.html#continuous), two-element array indicating  minimum
+# and maximum values, or an array with more than two entries for specifying a [piecewise
+# scale](scale.html#piecewise).
+#
+# - For [discrete](scale.html#discrete) and [discretizing](scale.html#discretizing) scales,
+# an array of desired output values.
+#
+# __Notes:__
+#
+# 1) For [sequential](scale.html#sequential), [ordinal](scale.html#ordinal), and
+# discretizing color scales, you can also specify a color [`scheme`](scale.html#scheme)
+# instead of `range`.
+#
+# 2) Any directly specified `range` for `x` and `y` channels will be ignored. Range can be
+# customized via the view's corresponding [size](size.html) (`width` and `height`) or via
+# [range steps and paddings properties](#range-step) for [band](#band) and [point](#point)
+# scales.
+alias ScaleRange = String | Array(PrecisionValue)
+
+# A string indicating a color [scheme](scale.html#scheme) name (e.g., `"category10"` or
+# `"viridis"`) or a [scheme parameter object](scale.html#scheme-params).
+#
+# Discrete color schemes may be used with [discrete](scale.html#discrete) or
+# [discretizing](scale.html#discretizing) scales. Continuous color schemes are intended for
+# use with [sequential](scales.html#sequential) scales.
+#
+# For the full list of supported scheme, please refer to the [Vega
+# Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
+alias Scheme = String | SchemeParams
+
+alias SortUnion = String | SortField
+
+# A constant value in visual domain (e.g., `"red"` / "#0099ff" for color, values between
+# `0` to `1` for opacity).
+#
+# A constant value in visual domain.
+alias ConditionalPredicateValueDefValue = Float64 | Bool | String
+
+alias Detail = FieldDef | Array(FieldDef)
+
+alias HrefCondition = ConditionalPredicateFieldDefClass | Array(ConditionalValueDef)
+
+alias Order = OrderFieldDef | Array(OrderFieldDef)
+
+alias TextCondition = ConditionalPredicateTextFieldDefClass | Array(ConditionalValueDef)
+
+alias AxisValue = DateTime | Float64
+
+# A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
+# `"line"`,
+# * `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark definition
+# object](mark.html#mark-def).
+alias AnyMark = MarkDef | String
+
+# A string or array of strings indicating the name of custom styles to apply to the mark. A
+# style is a named collection of mark property defaults defined within the [style
+# configuration](mark.html#style-config). If style is an array, later styles will override
+# earlier styles. Any [mark properties](encoding.html#mark-prop) explicitly defined within
+# the `encoding` will override a style default.
+#
+# __Default value:__ The mark's name.  For example, a bar mark will have style `"bar"` by
+# default.
+# __Note:__ Any specified style will augment the default style. For example, a bar mark
+# with `"style": "foo"` will receive from `config.style.bar` and `config.style.foo` (the
+# specified style `"foo"` has higher precedence).
+#
+# A [mark style property](config.html#style) to apply to the title text mark.
+#
+# __Default value:__ `"group-title"`.
+alias Style = String | Array(String)
+
+alias BindUnion = String | Hash(String, VgBinding)
+
+alias Title = String | TitleParams
diff --git a/head/schema-dart/test/inputs/schema/bool-string.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/bool-string.schema/default/TopLevel.dart
new file mode 100644
index 0000000..dd09fef
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/bool-string.schema/default/TopLevel.dart
@@ -0,0 +1,49 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<String?>? arrNullable;
+    final List<String>? arrOne;
+    final String? nullable;
+    final String one;
+    final String? optional;
+    final dynamic unionWithBool;
+    final dynamic unionWithBoolAndEnum;
+
+    TopLevel({
+        this.arrNullable,
+        this.arrOne,
+        required this.nullable,
+        required this.one,
+        this.optional,
+        required this.unionWithBool,
+        required this.unionWithBoolAndEnum,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        arrNullable: json["arrNullable"] == null ? null : List<String?>.from(json["arrNullable"]!.map((x) => x)),
+        arrOne: json["arrOne"] == null ? null : List<String>.from(json["arrOne"]!.map((x) => x)),
+        nullable: json["nullable"],
+        one: json["one"],
+        optional: json["optional"],
+        unionWithBool: json["unionWithBool"],
+        unionWithBoolAndEnum: json["unionWithBoolAndEnum"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "arrNullable": arrNullable == null ? null : List<dynamic>.from(arrNullable!.map((x) => x)),
+        "arrOne": arrOne == null ? null : List<dynamic>.from(arrOne!.map((x) => x)),
+        "nullable": nullable,
+        "one": one,
+        "optional": optional,
+        "unionWithBool": unionWithBool,
+        "unionWithBoolAndEnum": unionWithBoolAndEnum,
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/const-non-string.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/const-non-string.schema/default/TopLevel.dart
new file mode 100644
index 0000000..d75cbac
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/const-non-string.schema/default/TopLevel.dart
@@ -0,0 +1,61 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final int amount;
+    final bool enabled;
+    final Kind kind;
+    final double ratio;
+    final double version;
+
+    TopLevel({
+        required this.amount,
+        required this.enabled,
+        required this.kind,
+        required this.ratio,
+        required this.version,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        amount: json["amount"],
+        enabled: json["enabled"],
+        kind: kindValues.map[json["kind"]]!,
+        ratio: json["ratio"]?.toDouble(),
+        version: json["version"]?.toDouble(),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "amount": amount,
+        "enabled": enabled,
+        "kind": kindValues.reverse[kind],
+        "ratio": ratio,
+        "version": version,
+    };
+}
+
+enum Kind {
+    WIDGET
+}
+
+final kindValues = EnumValues({
+    "widget": Kind.WIDGET
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/schema-dart/test/inputs/schema/enum-large.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/enum-large.schema/default/TopLevel.dart
new file mode 100644
index 0000000..b084bcf
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/enum-large.schema/default/TopLevel.dart
@@ -0,0 +1,99 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final Callsign callsign;
+    final Priority priority;
+
+    TopLevel({
+        required this.callsign,
+        required this.priority,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        callsign: callsignValues.map[json["callsign"]]!,
+        priority: priorityValues.map[json["priority"]]!,
+    );
+
+    Map<String, dynamic> toJson() => {
+        "callsign": callsignValues.reverse[callsign],
+        "priority": priorityValues.reverse[priority],
+    };
+}
+
+enum Callsign {
+    ALPHA,
+    BRAVO,
+    CHARLIE,
+    DELTA,
+    ECHO,
+    FOXTROT,
+    GOLF,
+    HOTEL,
+    INDIA,
+    JULIETT,
+    KILO,
+    LIMA,
+    MIKE,
+    NOVEMBER,
+    OSCAR,
+    PAPA,
+    QUEBEC,
+    ROMEO,
+    SIERRA,
+    TANGO
+}
+
+final callsignValues = EnumValues({
+    "alpha": Callsign.ALPHA,
+    "bravo": Callsign.BRAVO,
+    "charlie": Callsign.CHARLIE,
+    "delta": Callsign.DELTA,
+    "echo": Callsign.ECHO,
+    "foxtrot": Callsign.FOXTROT,
+    "golf": Callsign.GOLF,
+    "hotel": Callsign.HOTEL,
+    "india": Callsign.INDIA,
+    "juliett": Callsign.JULIETT,
+    "kilo": Callsign.KILO,
+    "lima": Callsign.LIMA,
+    "mike": Callsign.MIKE,
+    "november": Callsign.NOVEMBER,
+    "oscar": Callsign.OSCAR,
+    "papa": Callsign.PAPA,
+    "quebec": Callsign.QUEBEC,
+    "romeo": Callsign.ROMEO,
+    "sierra": Callsign.SIERRA,
+    "tango": Callsign.TANGO
+});
+
+enum Priority {
+    LOW,
+    MEDIUM,
+    HIGH
+}
+
+final priorityValues = EnumValues({
+    "low": Priority.LOW,
+    "medium": Priority.MEDIUM,
+    "high": Priority.HIGH
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/schema-dart/test/inputs/schema/enum-with-null.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/enum-with-null.schema/default/TopLevel.dart
new file mode 100644
index 0000000..f8d7990
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/enum-with-null.schema/default/TopLevel.dart
@@ -0,0 +1,47 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final Enum? topLevelEnum;
+
+    TopLevel({
+        required this.topLevelEnum,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        topLevelEnum: enumValues.map[json["enum"]],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "enum": enumValues.reverse[topLevelEnum],
+    };
+}
+
+enum Enum {
+    FOO,
+    BAR
+}
+
+final enumValues = EnumValues({
+    "foo": Enum.FOO,
+    "bar": Enum.BAR
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/schema-dart/test/inputs/schema/enum.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/enum.schema/default/TopLevel.dart
new file mode 100644
index 0000000..1150433
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/enum.schema/default/TopLevel.dart
@@ -0,0 +1,89 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<dynamic>? arr;
+    final String? topLevelFor;
+    final Gve gve;
+    final Lvc? lvc;
+    final List<OtherArr>? otherArr;
+
+    TopLevel({
+        this.arr,
+        this.topLevelFor,
+        required this.gve,
+        this.lvc,
+        this.otherArr,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        arr: json["arr"] == null ? null : List<dynamic>.from(json["arr"]!.map((x) => x)),
+        topLevelFor: json["for"],
+        gve: gveValues.map[json["gve"]]!,
+        lvc: lvcValues.map[json["lvc"]],
+        otherArr: json["otherArr"] == null ? null : List<OtherArr>.from(json["otherArr"]!.map((x) => otherArrValues.map[x]!)),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "arr": arr == null ? null : List<dynamic>.from(arr!.map((x) => x)),
+        "for": topLevelFor,
+        "gve": gveValues.reverse[gve],
+        "lvc": lvcValues.reverse[lvc],
+        "otherArr": otherArr == null ? null : List<dynamic>.from(otherArr!.map((x) => otherArrValues.reverse[x])),
+    };
+}
+
+enum OtherArr {
+    FOO,
+    BAR,
+    IF
+}
+
+final otherArrValues = EnumValues({
+    "foo": OtherArr.FOO,
+    "bar": OtherArr.BAR,
+    "if": OtherArr.IF
+});
+
+enum Gve {
+    GOOD,
+    NEUTRAL,
+    EVIL
+}
+
+final gveValues = EnumValues({
+    "good": Gve.GOOD,
+    "neutral": Gve.NEUTRAL,
+    "evil": Gve.EVIL
+});
+
+enum Lvc {
+    LAWFUL,
+    NEUTRAL,
+    CHAOTIC
+}
+
+final lvcValues = EnumValues({
+    "lawful": Lvc.LAWFUL,
+    "neutral": Lvc.NEUTRAL,
+    "chaotic": Lvc.CHAOTIC
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/schema-dart/test/inputs/schema/integer-string.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/integer-string.schema/default/TopLevel.dart
new file mode 100644
index 0000000..106a7ec
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/integer-string.schema/default/TopLevel.dart
@@ -0,0 +1,49 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<String?>? arrNullable;
+    final List<String>? arrOne;
+    final String? nullable;
+    final String one;
+    final String? optional;
+    final dynamic unionWithInt;
+    final dynamic unionWithIntAndEnum;
+
+    TopLevel({
+        this.arrNullable,
+        this.arrOne,
+        required this.nullable,
+        required this.one,
+        this.optional,
+        required this.unionWithInt,
+        required this.unionWithIntAndEnum,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        arrNullable: json["arrNullable"] == null ? null : List<String?>.from(json["arrNullable"]!.map((x) => x)),
+        arrOne: json["arrOne"] == null ? null : List<String>.from(json["arrOne"]!.map((x) => x)),
+        nullable: json["nullable"],
+        one: json["one"],
+        optional: json["optional"],
+        unionWithInt: json["unionWithInt"],
+        unionWithIntAndEnum: json["unionWithIntAndEnum"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "arrNullable": arrNullable == null ? null : List<dynamic>.from(arrNullable!.map((x) => x)),
+        "arrOne": arrOne == null ? null : List<dynamic>.from(arrOne!.map((x) => x)),
+        "nullable": nullable,
+        "one": one,
+        "optional": optional,
+        "unionWithInt": unionWithInt,
+        "unionWithIntAndEnum": unionWithIntAndEnum,
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/intersection.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/intersection.schema/default/TopLevel.dart
new file mode 100644
index 0000000..2161d1c
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/intersection.schema/default/TopLevel.dart
@@ -0,0 +1,45 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final Intersection? intersection;
+
+    TopLevel({
+        this.intersection,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        intersection: json["intersection"] == null ? null : Intersection.fromJson(json["intersection"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "intersection": intersection?.toJson(),
+    };
+}
+
+class Intersection {
+    final double foo;
+    final String? bar;
+
+    Intersection({
+        required this.foo,
+        this.bar,
+    });
+
+    factory Intersection.fromJson(Map<String, dynamic> json) => Intersection(
+        foo: json["foo"]?.toDouble(),
+        bar: json["bar"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "foo": foo,
+        "bar": bar,
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/keyword-enum.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/keyword-enum.schema/default/TopLevel.dart
new file mode 100644
index 0000000..174fd43
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/keyword-enum.schema/default/TopLevel.dart
@@ -0,0 +1,597 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final Enum? topLevelEnum;
+
+    TopLevel({
+        this.topLevelEnum,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        topLevelEnum: enumValues.map[json["enum"]],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "enum": enumValues.reverse[topLevelEnum],
+    };
+}
+
+enum Enum {
+    EMPTY,
+    BOOL,
+    COMPLEX,
+    IMAGINERY,
+    ABSTRACT,
+    ALIGNAS,
+    ALIGNOF,
+    AND,
+    AND_EQ,
+    ANY,
+    ENUM_ANY,
+    ARRAY,
+    AS,
+    ASM,
+    ASSERT,
+    ASSOCIATEDTYPE,
+    ASSOCIATIVITY,
+    ASYNC,
+    ATOMIC,
+    ATOMIC_CANCEL,
+    ATOMIC_COMMIT,
+    ATOMIC_NOEXCEPT,
+    AUTO,
+    AWAIT,
+    BASE,
+    BITAND,
+    BITOR,
+    ENUM_BOOL,
+    PURPLE_BOOL,
+    BOOLEAN,
+    BREAK,
+    BYCOPY,
+    BYREF,
+    BYTE,
+    CASE,
+    CATCH,
+    CHAN,
+    CHAR,
+    CHAR16_T,
+    CHAR32_T,
+    CHECKED,
+    CLASS,
+    ENUM_CLASS,
+    CO_AWAIT,
+    CO_RETURN,
+    CO_YIELD,
+    COMPL,
+    CONCEPT,
+    CONSOLE,
+    CONST,
+    CONST_CAST,
+    CONSTEXPR,
+    CONSTRUCTOR,
+    CONTINUE,
+    CONVENIENCE,
+    CONVERT,
+    CONVERTER,
+    DATE,
+    DATE_PARSE_HANDLING,
+    DEBUGGER,
+    DECIMAL,
+    DECLARE,
+    DECLTYPE,
+    DECODE_STRING,
+    DEF,
+    DEFAULT,
+    DEFER,
+    DEINIT,
+    DEL,
+    DELEGATE,
+    DELETE,
+    DICT,
+    DICTIONARY,
+    DID_SET,
+    DO,
+    DOUBLE,
+    DYNAMIC,
+    DYNAMIC_CAST,
+    ELIF,
+    ELSE,
+    ENCODE_QUICK_TYPE,
+    ENUM,
+    EVENT,
+    EXCEPT,
+    EXCEPTION,
+    EXPLICIT,
+    EXPORT,
+    EXPOSING,
+    EXTENDS,
+    EXTENSION,
+    EXTERN,
+    FALLTHROUGH,
+    FALSE,
+    ENUM_FALSE,
+    FILEPRIVATE,
+    FINAL,
+    FINALLY,
+    FIXED,
+    FLOAT,
+    FOR,
+    FOREACH,
+    FRIEND,
+    FROM,
+    FROM_JSON,
+    FUNC,
+    FUNCTION,
+    GET,
+    GLOBAL,
+    GO,
+    GOTO,
+    GUARD,
+    HAS_OWN_PROPERTY,
+    ID,
+    IF,
+    IMP,
+    IMPLEMENTS,
+    IMPLICIT,
+    IMPORT,
+    IN,
+    INDIRECT,
+    INFIX,
+    INIT,
+    INLINE,
+    INOUT,
+    INSTANCEOF,
+    INT,
+    INTERFACE,
+    INTERNAL,
+    ITERABLE,
+    IS,
+    JDEC,
+    JENC,
+    JPIPE,
+    JSON,
+    JSON_CONVERTER,
+    JSON_SERIALIZER,
+    JSON_TOKEN,
+    JSON_WRITER,
+    LAMBDA,
+    LAZY,
+    LEFT,
+    LET,
+    LIST,
+    LOCK,
+    LONG,
+    MAP,
+    METADATA_PROPERTY_HANDLING,
+    MODULE,
+    MUTABLE,
+    MUTATING,
+    NAMESPACE,
+    NATIVE,
+    NEW,
+    NEWTONSOFT,
+    NIL,
+    NO,
+    NOEXCEPT,
+    NONATOMIC,
+    NONE,
+    ENUM_NONE,
+    NONLOCAL,
+    NONMUTATING,
+    NOT,
+    NOT_EQ,
+    NS_STRING,
+    NULL,
+    ENUM_NULL,
+    NULLPTR,
+    NUMBER,
+    OBJECT,
+    OF,
+    ONEWAY,
+    OPEN,
+    OPERATOR,
+    OPTIONAL,
+    OR,
+    OR_EQ,
+    OUT,
+    OVERRIDE,
+    PACKAGE,
+    PARAMS,
+    PASS,
+    PORT,
+    POSTFIX,
+    PRECEDENCE,
+    PREFIX,
+    PRINT,
+    PRINTF,
+    PRIVATE,
+    PROTECTED,
+    PROTOCOL,
+    ENUM_PROTOCOL,
+    PUBLIC,
+    QUICKTYPE,
+    RAISE,
+    RANGE,
+    READONLY,
+    REF,
+    REGISTER,
+    REINTERPRET_CAST,
+    REPEAT,
+    REQUIRE,
+    REQUIRED,
+    REQUIRES,
+    RESTRICT,
+    RETAIN,
+    RETHROWS,
+    RETURN,
+    RIGHT,
+    SBYTE,
+    SEALED,
+    SEL,
+    SELECT,
+    SELF,
+    ENUM_SELF,
+    SERIALIZE,
+    SET,
+    SHORT,
+    SIGNED,
+    SIZEOF,
+    STACKALLOC,
+    STATIC,
+    STATIC_ASSERT,
+    STATIC_CAST,
+    STRICTFP,
+    STRING,
+    STRUCT,
+    SUBSCRIPT,
+    SUPER,
+    SWITCH,
+    SYMBOL,
+    SYNCHRONIZED,
+    SYSTEM,
+    TEMPLATE,
+    THEN,
+    THIS,
+    THREAD_LOCAL,
+    THROW,
+    THROWS,
+    TO_JSON,
+    TOP_LEVEL,
+    TRANSIENT,
+    TRUE,
+    ENUM_TRUE,
+    TRY,
+    TYPE,
+    ENUM_TYPE,
+    TYPEALIAS,
+    TYPEDEF,
+    TYPEID,
+    TYPENAME,
+    TYPEOF,
+    UINT,
+    ULONG,
+    UNCHECKED,
+    UNDEFINED,
+    UNION,
+    UNOWNED,
+    UNSAFE,
+    UNSIGNED,
+    USHORT,
+    USING,
+    VAR,
+    VIRTUAL,
+    VOID,
+    VOLATILE,
+    WCHAR_T,
+    WEAK,
+    WHERE,
+    WHILE,
+    WILL_SET,
+    WITH,
+    XOR,
+    XOR_EQ,
+    YES,
+    YIELD,
+    DUMMY
+}
+
+final enumValues = EnumValues({
+    "_": Enum.EMPTY,
+    "_Bool": Enum.BOOL,
+    "_Complex": Enum.COMPLEX,
+    "_Imaginery": Enum.IMAGINERY,
+    "abstract": Enum.ABSTRACT,
+    "alignas": Enum.ALIGNAS,
+    "alignof": Enum.ALIGNOF,
+    "and": Enum.AND,
+    "and_eq": Enum.AND_EQ,
+    "any": Enum.ANY,
+    "Any": Enum.ENUM_ANY,
+    "array": Enum.ARRAY,
+    "as": Enum.AS,
+    "asm": Enum.ASM,
+    "assert": Enum.ASSERT,
+    "associatedtype": Enum.ASSOCIATEDTYPE,
+    "associativity": Enum.ASSOCIATIVITY,
+    "async": Enum.ASYNC,
+    "atomic": Enum.ATOMIC,
+    "atomic_cancel": Enum.ATOMIC_CANCEL,
+    "atomic_commit": Enum.ATOMIC_COMMIT,
+    "atomic_noexcept": Enum.ATOMIC_NOEXCEPT,
+    "auto": Enum.AUTO,
+    "await": Enum.AWAIT,
+    "base": Enum.BASE,
+    "bitand": Enum.BITAND,
+    "bitor": Enum.BITOR,
+    "BOOL": Enum.ENUM_BOOL,
+    "bool": Enum.PURPLE_BOOL,
+    "boolean": Enum.BOOLEAN,
+    "break": Enum.BREAK,
+    "bycopy": Enum.BYCOPY,
+    "byref": Enum.BYREF,
+    "byte": Enum.BYTE,
+    "case": Enum.CASE,
+    "catch": Enum.CATCH,
+    "chan": Enum.CHAN,
+    "char": Enum.CHAR,
+    "char16_t": Enum.CHAR16_T,
+    "char32_t": Enum.CHAR32_T,
+    "checked": Enum.CHECKED,
+    "class": Enum.CLASS,
+    "Class": Enum.ENUM_CLASS,
+    "co_await": Enum.CO_AWAIT,
+    "co_return": Enum.CO_RETURN,
+    "co_yield": Enum.CO_YIELD,
+    "compl": Enum.COMPL,
+    "concept": Enum.CONCEPT,
+    "console": Enum.CONSOLE,
+    "const": Enum.CONST,
+    "const_cast": Enum.CONST_CAST,
+    "constexpr": Enum.CONSTEXPR,
+    "constructor": Enum.CONSTRUCTOR,
+    "continue": Enum.CONTINUE,
+    "convenience": Enum.CONVENIENCE,
+    "convert": Enum.CONVERT,
+    "converter": Enum.CONVERTER,
+    "date": Enum.DATE,
+    "date_parse_handling": Enum.DATE_PARSE_HANDLING,
+    "debugger": Enum.DEBUGGER,
+    "decimal": Enum.DECIMAL,
+    "declare": Enum.DECLARE,
+    "decltype": Enum.DECLTYPE,
+    "decode_string": Enum.DECODE_STRING,
+    "def": Enum.DEF,
+    "default": Enum.DEFAULT,
+    "defer": Enum.DEFER,
+    "deinit": Enum.DEINIT,
+    "del": Enum.DEL,
+    "delegate": Enum.DELEGATE,
+    "delete": Enum.DELETE,
+    "dict": Enum.DICT,
+    "dictionary": Enum.DICTIONARY,
+    "didSet": Enum.DID_SET,
+    "do": Enum.DO,
+    "double": Enum.DOUBLE,
+    "dynamic": Enum.DYNAMIC,
+    "dynamic_cast": Enum.DYNAMIC_CAST,
+    "elif": Enum.ELIF,
+    "else": Enum.ELSE,
+    "encode_quick_type": Enum.ENCODE_QUICK_TYPE,
+    "enum": Enum.ENUM,
+    "event": Enum.EVENT,
+    "except": Enum.EXCEPT,
+    "exception": Enum.EXCEPTION,
+    "explicit": Enum.EXPLICIT,
+    "export": Enum.EXPORT,
+    "exposing": Enum.EXPOSING,
+    "extends": Enum.EXTENDS,
+    "extension": Enum.EXTENSION,
+    "extern": Enum.EXTERN,
+    "fallthrough": Enum.FALLTHROUGH,
+    "false": Enum.FALSE,
+    "False": Enum.ENUM_FALSE,
+    "fileprivate": Enum.FILEPRIVATE,
+    "final": Enum.FINAL,
+    "finally": Enum.FINALLY,
+    "fixed": Enum.FIXED,
+    "float": Enum.FLOAT,
+    "for": Enum.FOR,
+    "foreach": Enum.FOREACH,
+    "friend": Enum.FRIEND,
+    "from": Enum.FROM,
+    "from_json": Enum.FROM_JSON,
+    "func": Enum.FUNC,
+    "function": Enum.FUNCTION,
+    "get": Enum.GET,
+    "global": Enum.GLOBAL,
+    "go": Enum.GO,
+    "goto": Enum.GOTO,
+    "guard": Enum.GUARD,
+    "hasOwnProperty": Enum.HAS_OWN_PROPERTY,
+    "id": Enum.ID,
+    "if": Enum.IF,
+    "IMP": Enum.IMP,
+    "implements": Enum.IMPLEMENTS,
+    "implicit": Enum.IMPLICIT,
+    "import": Enum.IMPORT,
+    "in": Enum.IN,
+    "indirect": Enum.INDIRECT,
+    "infix": Enum.INFIX,
+    "init": Enum.INIT,
+    "inline": Enum.INLINE,
+    "inout": Enum.INOUT,
+    "instanceof": Enum.INSTANCEOF,
+    "int": Enum.INT,
+    "interface": Enum.INTERFACE,
+    "internal": Enum.INTERNAL,
+    "iterable": Enum.ITERABLE,
+    "is": Enum.IS,
+    "jdec": Enum.JDEC,
+    "jenc": Enum.JENC,
+    "jpipe": Enum.JPIPE,
+    "json": Enum.JSON,
+    "json_converter": Enum.JSON_CONVERTER,
+    "json_serializer": Enum.JSON_SERIALIZER,
+    "json_token": Enum.JSON_TOKEN,
+    "json_writer": Enum.JSON_WRITER,
+    "lambda": Enum.LAMBDA,
+    "lazy": Enum.LAZY,
+    "left": Enum.LEFT,
+    "let": Enum.LET,
+    "list": Enum.LIST,
+    "lock": Enum.LOCK,
+    "long": Enum.LONG,
+    "map": Enum.MAP,
+    "metadata_property_handling": Enum.METADATA_PROPERTY_HANDLING,
+    "module": Enum.MODULE,
+    "mutable": Enum.MUTABLE,
+    "mutating": Enum.MUTATING,
+    "namespace": Enum.NAMESPACE,
+    "native": Enum.NATIVE,
+    "new": Enum.NEW,
+    "newtonsoft": Enum.NEWTONSOFT,
+    "nil": Enum.NIL,
+    "NO": Enum.NO,
+    "noexcept": Enum.NOEXCEPT,
+    "nonatomic": Enum.NONATOMIC,
+    "none": Enum.NONE,
+    "None": Enum.ENUM_NONE,
+    "nonlocal": Enum.NONLOCAL,
+    "nonmutating": Enum.NONMUTATING,
+    "not": Enum.NOT,
+    "not_eq": Enum.NOT_EQ,
+    "NSString": Enum.NS_STRING,
+    "NULL": Enum.NULL,
+    "null": Enum.ENUM_NULL,
+    "nullptr": Enum.NULLPTR,
+    "number": Enum.NUMBER,
+    "object": Enum.OBJECT,
+    "of": Enum.OF,
+    "oneway": Enum.ONEWAY,
+    "open": Enum.OPEN,
+    "operator": Enum.OPERATOR,
+    "optional": Enum.OPTIONAL,
+    "or": Enum.OR,
+    "or_eq": Enum.OR_EQ,
+    "out": Enum.OUT,
+    "override": Enum.OVERRIDE,
+    "package": Enum.PACKAGE,
+    "params": Enum.PARAMS,
+    "pass": Enum.PASS,
+    "port": Enum.PORT,
+    "postfix": Enum.POSTFIX,
+    "precedence": Enum.PRECEDENCE,
+    "prefix": Enum.PREFIX,
+    "print": Enum.PRINT,
+    "printf": Enum.PRINTF,
+    "private": Enum.PRIVATE,
+    "protected": Enum.PROTECTED,
+    "Protocol": Enum.PROTOCOL,
+    "protocol": Enum.ENUM_PROTOCOL,
+    "public": Enum.PUBLIC,
+    "quicktype": Enum.QUICKTYPE,
+    "raise": Enum.RAISE,
+    "range": Enum.RANGE,
+    "readonly": Enum.READONLY,
+    "ref": Enum.REF,
+    "register": Enum.REGISTER,
+    "reinterpret_cast": Enum.REINTERPRET_CAST,
+    "repeat": Enum.REPEAT,
+    "require": Enum.REQUIRE,
+    "required": Enum.REQUIRED,
+    "requires": Enum.REQUIRES,
+    "restrict": Enum.RESTRICT,
+    "retain": Enum.RETAIN,
+    "rethrows": Enum.RETHROWS,
+    "return": Enum.RETURN,
+    "right": Enum.RIGHT,
+    "sbyte": Enum.SBYTE,
+    "sealed": Enum.SEALED,
+    "SEL": Enum.SEL,
+    "select": Enum.SELECT,
+    "Self": Enum.SELF,
+    "self": Enum.ENUM_SELF,
+    "serialize": Enum.SERIALIZE,
+    "set": Enum.SET,
+    "short": Enum.SHORT,
+    "signed": Enum.SIGNED,
+    "sizeof": Enum.SIZEOF,
+    "stackalloc": Enum.STACKALLOC,
+    "static": Enum.STATIC,
+    "static_assert": Enum.STATIC_ASSERT,
+    "static_cast": Enum.STATIC_CAST,
+    "strictfp": Enum.STRICTFP,
+    "string": Enum.STRING,
+    "struct": Enum.STRUCT,
+    "subscript": Enum.SUBSCRIPT,
+    "super": Enum.SUPER,
+    "switch": Enum.SWITCH,
+    "symbol": Enum.SYMBOL,
+    "synchronized": Enum.SYNCHRONIZED,
+    "system": Enum.SYSTEM,
+    "template": Enum.TEMPLATE,
+    "then": Enum.THEN,
+    "this": Enum.THIS,
+    "thread_local": Enum.THREAD_LOCAL,
+    "throw": Enum.THROW,
+    "throws": Enum.THROWS,
+    "to_json": Enum.TO_JSON,
+    "top_level": Enum.TOP_LEVEL,
+    "transient": Enum.TRANSIENT,
+    "True": Enum.TRUE,
+    "true": Enum.ENUM_TRUE,
+    "try": Enum.TRY,
+    "Type": Enum.TYPE,
+    "type": Enum.ENUM_TYPE,
+    "typealias": Enum.TYPEALIAS,
+    "typedef": Enum.TYPEDEF,
+    "typeid": Enum.TYPEID,
+    "typename": Enum.TYPENAME,
+    "typeof": Enum.TYPEOF,
+    "uint": Enum.UINT,
+    "ulong": Enum.ULONG,
+    "unchecked": Enum.UNCHECKED,
+    "undefined": Enum.UNDEFINED,
+    "union": Enum.UNION,
+    "unowned": Enum.UNOWNED,
+    "unsafe": Enum.UNSAFE,
+    "unsigned": Enum.UNSIGNED,
+    "ushort": Enum.USHORT,
+    "using": Enum.USING,
+    "var": Enum.VAR,
+    "virtual": Enum.VIRTUAL,
+    "void": Enum.VOID,
+    "volatile": Enum.VOLATILE,
+    "wchar_t": Enum.WCHAR_T,
+    "weak": Enum.WEAK,
+    "where": Enum.WHERE,
+    "while": Enum.WHILE,
+    "willSet": Enum.WILL_SET,
+    "with": Enum.WITH,
+    "xor": Enum.XOR,
+    "xor_eq": Enum.XOR_EQ,
+    "YES": Enum.YES,
+    "yield": Enum.YIELD,
+    "dummy": Enum.DUMMY
+});
+
+class EnumValues<T> {
+    Map<String, T> map;
+    late Map<T, String> reverseMap;
+
+    EnumValues(this.map);
+
+    Map<T, String> get reverse {
+            reverseMap = map.map((k, v) => MapEntry(v, k));
+            return reverseMap;
+    }
+}
diff --git a/head/schema-dart/test/inputs/schema/list.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/list.schema/default/TopLevel.dart
new file mode 100644
index 0000000..84ca054
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/list.schema/default/TopLevel.dart
@@ -0,0 +1,27 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+
+///A recursive class type
+class TopLevel {
+    final TopLevel? next;
+
+    TopLevel({
+        this.next,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "next": next?.toJson(),
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/mutually-recursive.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/mutually-recursive.schema/default/TopLevel.dart
new file mode 100644
index 0000000..75527ec
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/mutually-recursive.schema/default/TopLevel.dart
@@ -0,0 +1,41 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class Bar {
+    final dynamic foo;
+
+    Bar({
+        required this.foo,
+    });
+
+    factory Bar.fromJson(Map<String, dynamic> json) => Bar(
+        foo: json["foo"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "foo": foo,
+    };
+}
+
+class TopLevel {
+    final Bar? bar;
+
+    TopLevel({
+        this.bar,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        bar: json["bar"] == null ? null : Bar.fromJson(json["bar"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "bar": bar?.toJson(),
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/postman-collection.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/postman-collection.schema/default/TopLevel.dart
new file mode 100644
index 0000000..9ad5d9e
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/postman-collection.schema/default/TopLevel.dart
@@ -0,0 +1,51 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+
+///Postman collection
+class TopLevel {
+    final List<TopLevel>? item;
+    final String? name;
+    final List<Response>? response;
+
+    TopLevel({
+        this.item,
+        this.name,
+        this.response,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        item: json["item"] == null ? null : List<TopLevel>.from(json["item"]!.map((x) => TopLevel.fromJson(x))),
+        name: json["name"],
+        response: json["response"] == null ? null : List<Response>.from(json["response"]!.map((x) => Response.fromJson(x))),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "item": item == null ? null : List<dynamic>.from(item!.map((x) => x.toJson())),
+        "name": name,
+        "response": response == null ? null : List<dynamic>.from(response!.map((x) => x.toJson())),
+    };
+}
+
+class Response {
+    final String? body;
+
+    Response({
+        this.body,
+    });
+
+    factory Response.fromJson(Map<String, dynamic> json) => Response(
+        body: json["body"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "body": body,
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/ref-remote.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/ref-remote.schema/default/TopLevel.dart
new file mode 100644
index 0000000..84ca054
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/ref-remote.schema/default/TopLevel.dart
@@ -0,0 +1,27 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+
+///A recursive class type
+class TopLevel {
+    final TopLevel? next;
+
+    TopLevel({
+        this.next,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "next": next?.toJson(),
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/simple-ref.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/simple-ref.schema/default/TopLevel.dart
new file mode 100644
index 0000000..84ca054
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/simple-ref.schema/default/TopLevel.dart
@@ -0,0 +1,27 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+
+///A recursive class type
+class TopLevel {
+    final TopLevel? next;
+
+    TopLevel({
+        this.next,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        next: json["next"] == null ? null : TopLevel.fromJson(json["next"]),
+    );
+
+    Map<String, dynamic> toJson() => {
+        "next": next?.toJson(),
+    };
+}
diff --git a/head/schema-dart/test/inputs/schema/uuid.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/uuid.schema/default/TopLevel.dart
new file mode 100644
index 0000000..f019796
--- /dev/null
+++ b/head/schema-dart/test/inputs/schema/uuid.schema/default/TopLevel.dart
@@ -0,0 +1,45 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final List<String?>? arrNullable;
+    final List<String>? arrOne;
+    final String? nullable;
+    final String one;
+    final String? optional;
+    final String unionWithEnum;
+
+    TopLevel({
+        this.arrNullable,
+        this.arrOne,
+        required this.nullable,
+        required this.one,
+        this.optional,
+        required this.unionWithEnum,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        arrNullable: json["arrNullable"] == null ? null : List<String?>.from(json["arrNullable"]!.map((x) => x)),
+        arrOne: json["arrOne"] == null ? null : List<String>.from(json["arrOne"]!.map((x) => x)),
+        nullable: json["nullable"],
+        one: json["one"],
+        optional: json["optional"],
+        unionWithEnum: json["unionWithEnum"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "arrNullable": arrNullable == null ? null : List<dynamic>.from(arrNullable!.map((x) => x)),
+        "arrOne": arrOne == null ? null : List<dynamic>.from(arrOne!.map((x) => x)),
+        "nullable": nullable,
+        "one": one,
+        "optional": optional,
+        "unionWithEnum": unionWithEnum,
+    };
+}
diff --git a/base/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex
index f6d9cf3..b6a0188 100644
--- a/base/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex
@@ -68,7 +68,7 @@ defmodule TopLevel do
       barre: m["bar"],
       enumerification: EnumEnum.decode(m["enum"]),
       foo: m["foo"],
-      unionization: m["union"],
+      unionization: Map.fetch!(m, "union"),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex
index 8bd9c99..bbdd0bf 100644
--- a/base/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex
@@ -31,11 +31,11 @@ defmodule TopLevel do
     %TopLevel{
       arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
       arr_one: m["arrOne"],
-      nullable: m["nullable"],
+      nullable: Map.fetch!(m, "nullable"),
       one: m["one"],
       optional: m["optional"],
-      union_with_bool: m["unionWithBool"],
-      union_with_bool_and_enum: m["unionWithBoolAndEnum"],
+      union_with_bool: Map.fetch!(m, "unionWithBool"),
+      union_with_bool_and_enum: Map.fetch!(m, "unionWithBoolAndEnum"),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex
index 933eb3d..ef20c40 100644
--- a/base/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex
@@ -125,7 +125,7 @@ defmodule TopLevel do
       enum: EnumEnum.decode(m["enum"]),
       foo: m["foo"],
       object_or_string: decode_object_or_string(m["object-or-string"]),
-      union: m["union"],
+      union: Map.fetch!(m, "union"),
     }
   end
 
diff --git a/head/schema-elixir/test/inputs/schema/empty-object.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/empty-object.schema/default/QuickType.ex
new file mode 100644
index 0000000..10f0eee
--- /dev/null
+++ b/head/schema-elixir/test/inputs/schema/empty-object.schema/default/QuickType.ex
@@ -0,0 +1,20 @@
+# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
+#
+# Add Jason to your mix.exs
+#
+# Decode a JSON string: TopLevel.from_json(data)
+# Encode into a JSON string: TopLevel.to_json(struct)
+
+defmodule TopLevel do
+  def decode_value(value) when is_map(value), do: value
+
+  def from_json(json) do
+    json
+    |> Jason.decode!()
+    |> decode_value()
+  end
+
+  def to_json(data) do
+    Jason.encode!(data)
+  end
+end
diff --git a/base/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex
index 55627bf..865c4ee 100644
--- a/base/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex
@@ -31,11 +31,11 @@ defmodule TopLevel do
     %TopLevel{
       arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
       arr_one: m["arrOne"],
-      nullable: m["nullable"],
+      nullable: Map.fetch!(m, "nullable"),
       one: m["one"],
       optional: m["optional"],
-      union_with_int: m["unionWithInt"],
-      union_with_int_and_enum: m["unionWithIntAndEnum"],
+      union_with_int: Map.fetch!(m, "unionWithInt"),
+      union_with_int_and_enum: Map.fetch!(m, "unionWithIntAndEnum"),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex
index 31656f4..8773200 100644
--- a/base/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex
@@ -23,7 +23,7 @@ defmodule TopLevel do
   def from_map(m) do
     %TopLevel{
       intersection: m["intersection"],
-      in_union: m["inUnion"],
+      in_union: Map.fetch!(m, "inUnion"),
       maxlength: m["maxlength"],
       minlength: m["minlength"],
       min_max_intersection: m["minMaxIntersection"],
diff --git a/head/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex
new file mode 100644
index 0000000..0961fd1
--- /dev/null
+++ b/head/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex
@@ -0,0 +1,39 @@
+# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
+#
+# Add Jason to your mix.exs
+#
+# Decode a JSON string: TopLevel.from_json(data)
+# Encode into a JSON string: TopLevel.to_json(struct)
+
+defmodule TopLevel do
+  @enforce_keys [:foo]
+  defstruct [:foo]
+
+  @type t :: %__MODULE__{
+          foo: float() | nil
+        }
+
+  def from_map(m) do
+    %TopLevel{
+      foo: Map.fetch!(m, "foo"),
+    }
+  end
+
+  def from_json(json) do
+    json
+          |> Jason.decode!()
+          |> from_map()
+  end
+
+  def to_map(struct) do
+    %{
+      "foo" => struct.foo,
+    }
+  end
+
+  def to_json(struct) do
+    struct
+          |> to_map()
+          |> Jason.encode!()
+  end
+end
diff --git a/base/schema-elixir/test/inputs/schema/top-level-primitive.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/top-level-primitive.schema/default/QuickType.ex
index 4545f6d..2ac1f9b 100644
--- a/base/schema-elixir/test/inputs/schema/top-level-primitive.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/top-level-primitive.schema/default/QuickType.ex
@@ -11,7 +11,8 @@ defmodule TopLevel do
   """
 
   def from_json(json) do
-    Jason.decode!(json)
+    json
+    |> Jason.decode!()
   end
 
   def to_json(data) do
diff --git a/base/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex
index c40dc2d..bf1832c 100644
--- a/base/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex
@@ -15,7 +15,7 @@ defmodule TopLevel do
 
   def from_map(m) do
     %TopLevel{
-      value: m["value"],
+      value: Map.fetch!(m, "value"),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex
index 602006f..2d2be42 100644
--- a/base/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex
@@ -30,7 +30,7 @@ defmodule TopLevel do
     %TopLevel{
       arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
       arr_one: m["arrOne"],
-      nullable: m["nullable"],
+      nullable: Map.fetch!(m, "nullable"),
       one: m["one"],
       optional: m["optional"],
       union_with_enum: m["unionWithEnum"],
diff --git a/base/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex
index 0e82e11..95dafd7 100644
--- a/base/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex
@@ -4504,7 +4504,7 @@ defmodule ConditionalValueDef do
   def from_map(m) do
     %ConditionalValueDef{
       test: decode_test(m["test"]),
-      value: m["value"],
+      value: Map.fetch!(m, "value"),
       selection: decode_selection(m["selection"]),
     }
   end
diff --git a/head/schema-python/test/inputs/schema/keyword-unions.schema/default/quicktype.py b/head/schema-python/test/inputs/schema/keyword-unions.schema/default/quicktype.py
new file mode 100644
index 0000000..6f3e022
--- /dev/null
+++ b/head/schema-python/test/inputs/schema/keyword-unions.schema/default/quicktype.py
@@ -0,0 +1,5027 @@
+from dataclasses import dataclass
+from typing import Any, TypeVar, Type, cast
+
+
+T = TypeVar("T")
+
+
+def from_float(x: Any) -> float:
+    assert isinstance(x, (float, int)) and not isinstance(x, bool)
+    return float(x)
+
+
+def from_none(x: Any) -> Any:
+    assert x is None
+    return x
+
+
+def from_union(fs, x):
+    for f in fs:
+        try:
+            return f(x)
+        except:
+            pass
+    assert False
+
+
+def to_float(x: Any) -> float:
+    assert isinstance(x, (int, float))
+    return x
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    return cast(Any, x).to_dict()
+
+
+@dataclass
+class Abstract:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Abstract':
+        assert isinstance(obj, dict)
+        return Abstract()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Alignas:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Alignas':
+        assert isinstance(obj, dict)
+        return Alignas()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Alignof:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Alignof':
+        assert isinstance(obj, dict)
+        return Alignof()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class AndEq:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'AndEq':
+        assert isinstance(obj, dict)
+        return AndEq()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class AnyClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'AnyClass':
+        assert isinstance(obj, dict)
+        return AnyClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Array:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Array':
+        assert isinstance(obj, dict)
+        return Array()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ASM:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ASM':
+        assert isinstance(obj, dict)
+        return ASM()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Associatedtype:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Associatedtype':
+        assert isinstance(obj, dict)
+        return Associatedtype()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Associativity:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Associativity':
+        assert isinstance(obj, dict)
+        return Associativity()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Atomic:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Atomic':
+        assert isinstance(obj, dict)
+        return Atomic()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class AtomicCancel:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'AtomicCancel':
+        assert isinstance(obj, dict)
+        return AtomicCancel()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class AtomicCommit:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'AtomicCommit':
+        assert isinstance(obj, dict)
+        return AtomicCommit()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class AtomicNoexcept:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'AtomicNoexcept':
+        assert isinstance(obj, dict)
+        return AtomicNoexcept()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Auto:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Auto':
+        assert isinstance(obj, dict)
+        return Auto()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Base:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Base':
+        assert isinstance(obj, dict)
+        return Base()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Bitand:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Bitand':
+        assert isinstance(obj, dict)
+        return Bitand()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Bitor:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Bitor':
+        assert isinstance(obj, dict)
+        return Bitor()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Boolean:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Boolean':
+        assert isinstance(obj, dict)
+        return Boolean()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Bycopy:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Bycopy':
+        assert isinstance(obj, dict)
+        return Bycopy()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Byref:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Byref':
+        assert isinstance(obj, dict)
+        return Byref()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Byte:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Byte':
+        assert isinstance(obj, dict)
+        return Byte()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Case:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Case':
+        assert isinstance(obj, dict)
+        return Case()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Catch:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Catch':
+        assert isinstance(obj, dict)
+        return Catch()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Chan:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Chan':
+        assert isinstance(obj, dict)
+        return Chan()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Char:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Char':
+        assert isinstance(obj, dict)
+        return Char()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Char16T:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Char16T':
+        assert isinstance(obj, dict)
+        return Char16T()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Char32T:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Char32T':
+        assert isinstance(obj, dict)
+        return Char32T()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Checked:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Checked':
+        assert isinstance(obj, dict)
+        return Checked()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class CoAwait:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'CoAwait':
+        assert isinstance(obj, dict)
+        return CoAwait()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class CoReturn:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'CoReturn':
+        assert isinstance(obj, dict)
+        return CoReturn()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class CoYield:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'CoYield':
+        assert isinstance(obj, dict)
+        return CoYield()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Compl:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Compl':
+        assert isinstance(obj, dict)
+        return Compl()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Complex:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Complex':
+        assert isinstance(obj, dict)
+        return Complex()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Concept:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Concept':
+        assert isinstance(obj, dict)
+        return Concept()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Console:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Console':
+        assert isinstance(obj, dict)
+        return Console()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Const:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Const':
+        assert isinstance(obj, dict)
+        return Const()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ConstCast:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ConstCast':
+        assert isinstance(obj, dict)
+        return ConstCast()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Constexpr:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Constexpr':
+        assert isinstance(obj, dict)
+        return Constexpr()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Constructor:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Constructor':
+        assert isinstance(obj, dict)
+        return Constructor()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Convenience:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Convenience':
+        assert isinstance(obj, dict)
+        return Convenience()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Convert:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Convert':
+        assert isinstance(obj, dict)
+        return Convert()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Converter:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Converter':
+        assert isinstance(obj, dict)
+        return Converter()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Date:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Date':
+        assert isinstance(obj, dict)
+        return Date()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class DateParseHandling:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'DateParseHandling':
+        assert isinstance(obj, dict)
+        return DateParseHandling()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Debugger:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Debugger':
+        assert isinstance(obj, dict)
+        return Debugger()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Decimal:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Decimal':
+        assert isinstance(obj, dict)
+        return Decimal()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Declare:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Declare':
+        assert isinstance(obj, dict)
+        return Declare()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Decltype:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Decltype':
+        assert isinstance(obj, dict)
+        return Decltype()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class DecodeString:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'DecodeString':
+        assert isinstance(obj, dict)
+        return DecodeString()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Default:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Default':
+        assert isinstance(obj, dict)
+        return Default()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Defer:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Defer':
+        assert isinstance(obj, dict)
+        return Defer()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Deinit:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Deinit':
+        assert isinstance(obj, dict)
+        return Deinit()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Delegate:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Delegate':
+        assert isinstance(obj, dict)
+        return Delegate()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Delete:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Delete':
+        assert isinstance(obj, dict)
+        return Delete()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Dictionary:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Dictionary':
+        assert isinstance(obj, dict)
+        return Dictionary()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class DidSet:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'DidSet':
+        assert isinstance(obj, dict)
+        return DidSet()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Do:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Do':
+        assert isinstance(obj, dict)
+        return Do()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Double:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Double':
+        assert isinstance(obj, dict)
+        return Double()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Dynamic:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Dynamic':
+        assert isinstance(obj, dict)
+        return Dynamic()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class DynamicCast:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'DynamicCast':
+        assert isinstance(obj, dict)
+        return DynamicCast()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Empty:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Empty':
+        assert isinstance(obj, dict)
+        return Empty()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class EncodeQuickType:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'EncodeQuickType':
+        assert isinstance(obj, dict)
+        return EncodeQuickType()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class EnumClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'EnumClass':
+        assert isinstance(obj, dict)
+        return EnumClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Event:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Event':
+        assert isinstance(obj, dict)
+        return Event()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Exception:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Exception':
+        assert isinstance(obj, dict)
+        return Exception()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Explicit:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Explicit':
+        assert isinstance(obj, dict)
+        return Explicit()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Export:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Export':
+        assert isinstance(obj, dict)
+        return Export()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Exposing:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Exposing':
+        assert isinstance(obj, dict)
+        return Exposing()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Extends:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Extends':
+        assert isinstance(obj, dict)
+        return Extends()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Extension:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Extension':
+        assert isinstance(obj, dict)
+        return Extension()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Extern:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Extern':
+        assert isinstance(obj, dict)
+        return Extern()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Fallthrough:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Fallthrough':
+        assert isinstance(obj, dict)
+        return Fallthrough()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class FalseClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'FalseClass':
+        assert isinstance(obj, dict)
+        return FalseClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Fileprivate:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Fileprivate':
+        assert isinstance(obj, dict)
+        return Fileprivate()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Final:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Final':
+        assert isinstance(obj, dict)
+        return Final()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Fixed:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Fixed':
+        assert isinstance(obj, dict)
+        return Fixed()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionBoolBool:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionBoolBool':
+        assert isinstance(obj, dict)
+        return UnionBoolBool()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Foreach:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Foreach':
+        assert isinstance(obj, dict)
+        return Foreach()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Friend:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Friend':
+        assert isinstance(obj, dict)
+        return Friend()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class FromJSON:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'FromJSON':
+        assert isinstance(obj, dict)
+        return FromJSON()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Func:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Func':
+        assert isinstance(obj, dict)
+        return Func()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Function:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Function':
+        assert isinstance(obj, dict)
+        return Function()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Get:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Get':
+        assert isinstance(obj, dict)
+        return Get()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Go:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Go':
+        assert isinstance(obj, dict)
+        return Go()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Goto:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Goto':
+        assert isinstance(obj, dict)
+        return Goto()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Guard:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Guard':
+        assert isinstance(obj, dict)
+        return Guard()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class HasOwnProperty:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'HasOwnProperty':
+        assert isinstance(obj, dict)
+        return HasOwnProperty()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ID:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ID':
+        assert isinstance(obj, dict)
+        return ID()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Imaginery:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Imaginery':
+        assert isinstance(obj, dict)
+        return Imaginery()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Imp:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Imp':
+        assert isinstance(obj, dict)
+        return Imp()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Implements:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Implements':
+        assert isinstance(obj, dict)
+        return Implements()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Implicit:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Implicit':
+        assert isinstance(obj, dict)
+        return Implicit()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Indirect:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Indirect':
+        assert isinstance(obj, dict)
+        return Indirect()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Infix:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Infix':
+        assert isinstance(obj, dict)
+        return Infix()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Init:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Init':
+        assert isinstance(obj, dict)
+        return Init()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Inline:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Inline':
+        assert isinstance(obj, dict)
+        return Inline()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Inout:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Inout':
+        assert isinstance(obj, dict)
+        return Inout()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Instanceof:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Instanceof':
+        assert isinstance(obj, dict)
+        return Instanceof()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Interface:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Interface':
+        assert isinstance(obj, dict)
+        return Interface()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Internal:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Internal':
+        assert isinstance(obj, dict)
+        return Internal()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class IterableClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IterableClass':
+        assert isinstance(obj, dict)
+        return IterableClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Jdec:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Jdec':
+        assert isinstance(obj, dict)
+        return Jdec()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Jenc:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Jenc':
+        assert isinstance(obj, dict)
+        return Jenc()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Jpipe:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Jpipe':
+        assert isinstance(obj, dict)
+        return Jpipe()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class JSON:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'JSON':
+        assert isinstance(obj, dict)
+        return JSON()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class JSONConverter:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'JSONConverter':
+        assert isinstance(obj, dict)
+        return JSONConverter()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class JSONSerializer:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'JSONSerializer':
+        assert isinstance(obj, dict)
+        return JSONSerializer()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class JSONToken:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'JSONToken':
+        assert isinstance(obj, dict)
+        return JSONToken()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class JSONWriter:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'JSONWriter':
+        assert isinstance(obj, dict)
+        return JSONWriter()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Lazy:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Lazy':
+        assert isinstance(obj, dict)
+        return Lazy()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Left:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Left':
+        assert isinstance(obj, dict)
+        return Left()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Let:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Let':
+        assert isinstance(obj, dict)
+        return Let()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ListClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ListClass':
+        assert isinstance(obj, dict)
+        return ListClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Lock:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Lock':
+        assert isinstance(obj, dict)
+        return Lock()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Long:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Long':
+        assert isinstance(obj, dict)
+        return Long()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Map:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Map':
+        assert isinstance(obj, dict)
+        return Map()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class MetadataPropertyHandling:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MetadataPropertyHandling':
+        assert isinstance(obj, dict)
+        return MetadataPropertyHandling()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Module:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Module':
+        assert isinstance(obj, dict)
+        return Module()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Mutable:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Mutable':
+        assert isinstance(obj, dict)
+        return Mutable()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Mutating:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Mutating':
+        assert isinstance(obj, dict)
+        return Mutating()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Namespace:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Namespace':
+        assert isinstance(obj, dict)
+        return Namespace()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Native:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Native':
+        assert isinstance(obj, dict)
+        return Native()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class New:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'New':
+        assert isinstance(obj, dict)
+        return New()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Newtonsoft:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Newtonsoft':
+        assert isinstance(obj, dict)
+        return Newtonsoft()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Nil:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Nil':
+        assert isinstance(obj, dict)
+        return Nil()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class No:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'No':
+        assert isinstance(obj, dict)
+        return No()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Noexcept:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Noexcept':
+        assert isinstance(obj, dict)
+        return Noexcept()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Nonatomic:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Nonatomic':
+        assert isinstance(obj, dict)
+        return Nonatomic()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class NoneClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'NoneClass':
+        assert isinstance(obj, dict)
+        return NoneClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Nonmutating:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Nonmutating':
+        assert isinstance(obj, dict)
+        return Nonmutating()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class NotEq:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'NotEq':
+        assert isinstance(obj, dict)
+        return NotEq()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class NSString:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'NSString':
+        assert isinstance(obj, dict)
+        return NSString()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Null:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Null':
+        assert isinstance(obj, dict)
+        return Null()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Nullptr:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Nullptr':
+        assert isinstance(obj, dict)
+        return Nullptr()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Number:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Number':
+        assert isinstance(obj, dict)
+        return Number()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Object:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Object':
+        assert isinstance(obj, dict)
+        return Object()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Of:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Of':
+        assert isinstance(obj, dict)
+        return Of()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Oneway:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Oneway':
+        assert isinstance(obj, dict)
+        return Oneway()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Open:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Open':
+        assert isinstance(obj, dict)
+        return Open()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Operator:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Operator':
+        assert isinstance(obj, dict)
+        return Operator()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class OptionalClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'OptionalClass':
+        assert isinstance(obj, dict)
+        return OptionalClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class OrEq:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'OrEq':
+        assert isinstance(obj, dict)
+        return OrEq()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Out:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Out':
+        assert isinstance(obj, dict)
+        return Out()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Override:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Override':
+        assert isinstance(obj, dict)
+        return Override()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Package:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Package':
+        assert isinstance(obj, dict)
+        return Package()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Params:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Params':
+        assert isinstance(obj, dict)
+        return Params()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Port:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Port':
+        assert isinstance(obj, dict)
+        return Port()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Postfix:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Postfix':
+        assert isinstance(obj, dict)
+        return Postfix()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Precedence:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Precedence':
+        assert isinstance(obj, dict)
+        return Precedence()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Prefix:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Prefix':
+        assert isinstance(obj, dict)
+        return Prefix()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Printf:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Printf':
+        assert isinstance(obj, dict)
+        return Printf()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Private:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Private':
+        assert isinstance(obj, dict)
+        return Private()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Protected:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Protected':
+        assert isinstance(obj, dict)
+        return Protected()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Protocol:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Protocol':
+        assert isinstance(obj, dict)
+        return Protocol()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Public:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Public':
+        assert isinstance(obj, dict)
+        return Public()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class BoolClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'BoolClass':
+        assert isinstance(obj, dict)
+        return BoolClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ClassClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ClassClass':
+        assert isinstance(obj, dict)
+        return ClassClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class SelfClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SelfClass':
+        assert isinstance(obj, dict)
+        return SelfClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Quicktype:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Quicktype':
+        assert isinstance(obj, dict)
+        return Quicktype()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Range:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Range':
+        assert isinstance(obj, dict)
+        return Range()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Readonly:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Readonly':
+        assert isinstance(obj, dict)
+        return Readonly()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Ref:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Ref':
+        assert isinstance(obj, dict)
+        return Ref()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Register:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Register':
+        assert isinstance(obj, dict)
+        return Register()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ReinterpretCast:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ReinterpretCast':
+        assert isinstance(obj, dict)
+        return ReinterpretCast()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Repeat:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Repeat':
+        assert isinstance(obj, dict)
+        return Repeat()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Require:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Require':
+        assert isinstance(obj, dict)
+        return Require()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Required:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Required':
+        assert isinstance(obj, dict)
+        return Required()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Requires:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Requires':
+        assert isinstance(obj, dict)
+        return Requires()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Restrict:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Restrict':
+        assert isinstance(obj, dict)
+        return Restrict()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Retain:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Retain':
+        assert isinstance(obj, dict)
+        return Retain()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Rethrows:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Rethrows':
+        assert isinstance(obj, dict)
+        return Rethrows()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Right:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Right':
+        assert isinstance(obj, dict)
+        return Right()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Sbyte:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Sbyte':
+        assert isinstance(obj, dict)
+        return Sbyte()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Sealed:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Sealed':
+        assert isinstance(obj, dict)
+        return Sealed()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Sel:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Sel':
+        assert isinstance(obj, dict)
+        return Sel()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Select:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Select':
+        assert isinstance(obj, dict)
+        return Select()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Serialize:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Serialize':
+        assert isinstance(obj, dict)
+        return Serialize()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Set:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Set':
+        assert isinstance(obj, dict)
+        return Set()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Short:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Short':
+        assert isinstance(obj, dict)
+        return Short()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Signed:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Signed':
+        assert isinstance(obj, dict)
+        return Signed()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Sizeof:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Sizeof':
+        assert isinstance(obj, dict)
+        return Sizeof()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Stackalloc:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Stackalloc':
+        assert isinstance(obj, dict)
+        return Stackalloc()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Static:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Static':
+        assert isinstance(obj, dict)
+        return Static()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class StaticAssert:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'StaticAssert':
+        assert isinstance(obj, dict)
+        return StaticAssert()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class StaticCast:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'StaticCast':
+        assert isinstance(obj, dict)
+        return StaticCast()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Strictfp:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Strictfp':
+        assert isinstance(obj, dict)
+        return Strictfp()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class String:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'String':
+        assert isinstance(obj, dict)
+        return String()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Struct:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Struct':
+        assert isinstance(obj, dict)
+        return Struct()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Subscript:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Subscript':
+        assert isinstance(obj, dict)
+        return Subscript()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Super:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Super':
+        assert isinstance(obj, dict)
+        return Super()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Switch:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Switch':
+        assert isinstance(obj, dict)
+        return Switch()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Symbol:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Symbol':
+        assert isinstance(obj, dict)
+        return Symbol()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Synchronized:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Synchronized':
+        assert isinstance(obj, dict)
+        return Synchronized()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class System:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'System':
+        assert isinstance(obj, dict)
+        return System()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Template:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Template':
+        assert isinstance(obj, dict)
+        return Template()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Then:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Then':
+        assert isinstance(obj, dict)
+        return Then()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class This:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'This':
+        assert isinstance(obj, dict)
+        return This()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ThreadLocal:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ThreadLocal':
+        assert isinstance(obj, dict)
+        return ThreadLocal()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Throw:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Throw':
+        assert isinstance(obj, dict)
+        return Throw()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Throws:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Throws':
+        assert isinstance(obj, dict)
+        return Throws()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ToJSON:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ToJSON':
+        assert isinstance(obj, dict)
+        return ToJSON()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class TopLevelClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TopLevelClass':
+        assert isinstance(obj, dict)
+        return TopLevelClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class And:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'And':
+        assert isinstance(obj, dict)
+        return And()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionAnyAny:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionAnyAny':
+        assert isinstance(obj, dict)
+        return UnionAnyAny()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class As:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'As':
+        assert isinstance(obj, dict)
+        return As()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Assert:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Assert':
+        assert isinstance(obj, dict)
+        return Assert()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Async:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Async':
+        assert isinstance(obj, dict)
+        return Async()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Await:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Await':
+        assert isinstance(obj, dict)
+        return Await()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Bool:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Bool':
+        assert isinstance(obj, dict)
+        return Bool()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Break:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Break':
+        assert isinstance(obj, dict)
+        return Break()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Class:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Class':
+        assert isinstance(obj, dict)
+        return Class()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Continue:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Continue':
+        assert isinstance(obj, dict)
+        return Continue()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Def:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Def':
+        assert isinstance(obj, dict)
+        return Def()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Del:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Del':
+        assert isinstance(obj, dict)
+        return Del()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class DictClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'DictClass':
+        assert isinstance(obj, dict)
+        return DictClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Elif:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Elif':
+        assert isinstance(obj, dict)
+        return Elif()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Else:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Else':
+        assert isinstance(obj, dict)
+        return Else()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Except:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Except':
+        assert isinstance(obj, dict)
+        return Except()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionFalseFalse:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionFalseFalse':
+        assert isinstance(obj, dict)
+        return UnionFalseFalse()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Finally:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Finally':
+        assert isinstance(obj, dict)
+        return Finally()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Float:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Float':
+        assert isinstance(obj, dict)
+        return Float()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class For:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'For':
+        assert isinstance(obj, dict)
+        return For()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class From:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'From':
+        assert isinstance(obj, dict)
+        return From()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Global:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Global':
+        assert isinstance(obj, dict)
+        return Global()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class If:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'If':
+        assert isinstance(obj, dict)
+        return If()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Import:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Import':
+        assert isinstance(obj, dict)
+        return Import()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class In:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'In':
+        assert isinstance(obj, dict)
+        return In()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Int:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Int':
+        assert isinstance(obj, dict)
+        return Int()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Is:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Is':
+        assert isinstance(obj, dict)
+        return Is()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Lambda:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Lambda':
+        assert isinstance(obj, dict)
+        return Lambda()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionNoneNone:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionNoneNone':
+        assert isinstance(obj, dict)
+        return UnionNoneNone()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Nonlocal:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Nonlocal':
+        assert isinstance(obj, dict)
+        return Nonlocal()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Not:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Not':
+        assert isinstance(obj, dict)
+        return Not()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class NullClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'NullClass':
+        assert isinstance(obj, dict)
+        return NullClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Or:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Or':
+        assert isinstance(obj, dict)
+        return Or()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Pass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Pass':
+        assert isinstance(obj, dict)
+        return Pass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Print:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Print':
+        assert isinstance(obj, dict)
+        return Print()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class ProtocolClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ProtocolClass':
+        assert isinstance(obj, dict)
+        return ProtocolClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Raise:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Raise':
+        assert isinstance(obj, dict)
+        return Raise()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Return:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Return':
+        assert isinstance(obj, dict)
+        return Return()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Self:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Self':
+        assert isinstance(obj, dict)
+        return Self()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionTrueTrue:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionTrueTrue':
+        assert isinstance(obj, dict)
+        return UnionTrueTrue()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Try:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Try':
+        assert isinstance(obj, dict)
+        return Try()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionTypeType:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionTypeType':
+        assert isinstance(obj, dict)
+        return UnionTypeType()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class While:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'While':
+        assert isinstance(obj, dict)
+        return While()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class With:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'With':
+        assert isinstance(obj, dict)
+        return With()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Yield:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Yield':
+        assert isinstance(obj, dict)
+        return Yield()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Transient:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Transient':
+        assert isinstance(obj, dict)
+        return Transient()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class TrueClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TrueClass':
+        assert isinstance(obj, dict)
+        return TrueClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class TypeClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TypeClass':
+        assert isinstance(obj, dict)
+        return TypeClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Typealias:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Typealias':
+        assert isinstance(obj, dict)
+        return Typealias()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Typedef:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Typedef':
+        assert isinstance(obj, dict)
+        return Typedef()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Typeid:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Typeid':
+        assert isinstance(obj, dict)
+        return Typeid()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Typename:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Typename':
+        assert isinstance(obj, dict)
+        return Typename()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Typeof:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Typeof':
+        assert isinstance(obj, dict)
+        return Typeof()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Uint:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Uint':
+        assert isinstance(obj, dict)
+        return Uint()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Ulong:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Ulong':
+        assert isinstance(obj, dict)
+        return Ulong()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Unchecked:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Unchecked':
+        assert isinstance(obj, dict)
+        return Unchecked()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Undefined:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Undefined':
+        assert isinstance(obj, dict)
+        return Undefined()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class UnionClass:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'UnionClass':
+        assert isinstance(obj, dict)
+        return UnionClass()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Unowned:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Unowned':
+        assert isinstance(obj, dict)
+        return Unowned()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Unsafe:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Unsafe':
+        assert isinstance(obj, dict)
+        return Unsafe()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Unsigned:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Unsigned':
+        assert isinstance(obj, dict)
+        return Unsigned()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Ushort:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Ushort':
+        assert isinstance(obj, dict)
+        return Ushort()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Using:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Using':
+        assert isinstance(obj, dict)
+        return Using()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Var:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Var':
+        assert isinstance(obj, dict)
+        return Var()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Virtual:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Virtual':
+        assert isinstance(obj, dict)
+        return Virtual()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Void:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Void':
+        assert isinstance(obj, dict)
+        return Void()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Volatile:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Volatile':
+        assert isinstance(obj, dict)
+        return Volatile()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class WcharT:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'WcharT':
+        assert isinstance(obj, dict)
+        return WcharT()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Weak:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Weak':
+        assert isinstance(obj, dict)
+        return Weak()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Where:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Where':
+        assert isinstance(obj, dict)
+        return Where()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class WillSet:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'WillSet':
+        assert isinstance(obj, dict)
+        return WillSet()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Xor:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Xor':
+        assert isinstance(obj, dict)
+        return Xor()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class XorEq:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'XorEq':
+        assert isinstance(obj, dict)
+        return XorEq()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class Yes:
+    pass
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Yes':
+        assert isinstance(obj, dict)
+        return Yes()
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        return result
+
+
+@dataclass
+class TopLevel:
+    empty: float | Empty | None = None
+    purple_bool: float | BoolClass | None = None
+    complex: float | Complex | None = None
+    imaginery: float | Imaginery | None = None
+    abstract: float | Abstract | None = None
+    alignas: float | Alignas | None = None
+    alignof: float | Alignof | None = None
+    top_level_and: float | And | None = None
+    and_eq: float | AndEq | None = None
+    top_level_any: float | UnionAnyAny | None = None
+    any: float | AnyClass | None = None
+    array: float | Array | None = None
+    top_level_as: float | As | None = None
+    asm: float | ASM | None = None
+    top_level_assert: float | Assert | None = None
+    associatedtype: float | Associatedtype | None = None
+    associativity: float | Associativity | None = None
+    top_level_async: float | Async | None = None
+    atomic: float | Atomic | None = None
+    atomic_cancel: float | AtomicCancel | None = None
+    atomic_commit: float | AtomicCommit | None = None
+    atomic_noexcept: float | AtomicNoexcept | None = None
+    auto: float | Auto | None = None
+    top_level_await: float | Await | None = None
+    base: float | Base | None = None
+    bitand: float | Bitand | None = None
+    bitor: float | Bitor | None = None
+    top_level_bool: float | Bool | None = None
+    fluffy_bool: float | UnionBoolBool | None = None
+    boolean: float | Boolean | None = None
+    top_level_break: float | Break | None = None
+    bycopy: float | Bycopy | None = None
+    byref: float | Byref | None = None
+    byte: float | Byte | None = None
+    case: float | Case | None = None
+    catch: float | Catch | None = None
+    chan: float | Chan | None = None
+    char: float | Char | None = None
+    char16_t: float | Char16T | None = None
+    char32_t: float | Char32T | None = None
+    checked: float | Checked | None = None
+    purple_class: float | ClassClass | None = None
+    top_level_class: float | Class | None = None
+    co_await: float | CoAwait | None = None
+    co_return: float | CoReturn | None = None
+    co_yield: float | CoYield | None = None
+    compl: float | Compl | None = None
+    concept: float | Concept | None = None
+    console: float | Console | None = None
+    const: float | Const | None = None
+    const_cast: float | ConstCast | None = None
+    constexpr: float | Constexpr | None = None
+    constructor: float | Constructor | None = None
+    top_level_continue: float | Continue | None = None
+    convenience: float | Convenience | None = None
+    convert: float | Convert | None = None
+    converter: float | Converter | None = None
+    date: float | Date | None = None
+    date_parse_handling: float | DateParseHandling | None = None
+    debugger: float | Debugger | None = None
+    decimal: float | Decimal | None = None
+    declare: float | Declare | None = None
+    decltype: float | Decltype | None = None
+    decode_string: float | DecodeString | None = None
+    top_level_def: float | Def | None = None
+    default: float | Default | None = None
+    defer: float | Defer | None = None
+    deinit: float | Deinit | None = None
+    top_level_del: float | Del | None = None
+    delegate: float | Delegate | None = None
+    delete: float | Delete | None = None
+    top_level_dict: float | DictClass | None = None
+    dictionary: float | Dictionary | None = None
+    did_set: float | DidSet | None = None
+    do: float | Do | None = None
+    double: float | Double | None = None
+    dummy: float | None = None
+    dynamic: float | Dynamic | None = None
+    dynamic_cast: float | DynamicCast | None = None
+    top_level_elif: float | Elif | None = None
+    top_level_else: float | Else | None = None
+    encode_quick_type: float | EncodeQuickType | None = None
+    enum: float | EnumClass | None = None
+    event: float | Event | None = None
+    top_level_except: float | Except | None = None
+    exception: float | Exception | None = None
+    explicit: float | Explicit | None = None
+    export: float | Export | None = None
+    exposing: float | Exposing | None = None
+    extends: float | Extends | None = None
+    extension: float | Extension | None = None
+    extern: float | Extern | None = None
+    fallthrough: float | Fallthrough | None = None
+    top_level_false: float | UnionFalseFalse | None = None
+    false: float | FalseClass | None = None
+    fileprivate: float | Fileprivate | None = None
+    final: float | Final | None = None
+    top_level_finally: float | Finally | None = None
+    fixed: float | Fixed | None = None
+    top_level_float: float | Float | None = None
+    top_level_for: float | For | None = None
+    foreach: float | Foreach | None = None
+    friend: float | Friend | None = None
+    top_level_from: float | From | None = None
+    from_json: float | FromJSON | None = None
+    func: float | Func | None = None
+    function: float | Function | None = None
+    get: float | Get | None = None
+    top_level_global: float | Global | None = None
+    go: float | Go | None = None
+    goto: float | Goto | None = None
+    guard: float | Guard | None = None
+    has_own_property: float | HasOwnProperty | None = None
+    id: float | ID | None = None
+    top_level_if: float | If | None = None
+    imp: float | Imp | None = None
+    implements: float | Implements | None = None
+    implicit: float | Implicit | None = None
+    top_level_import: float | Import | None = None
+    top_level_in: float | In | None = None
+    indirect: float | Indirect | None = None
+    infix: float | Infix | None = None
+    init: float | Init | None = None
+    inline: float | Inline | None = None
+    inout: float | Inout | None = None
+    instanceof: float | Instanceof | None = None
+    top_level_int: float | Int | None = None
+    interface: float | Interface | None = None
+    internal: float | Internal | None = None
+    top_level_is: float | Is | None = None
+    iterable: float | IterableClass | None = None
+    jdec: float | Jdec | None = None
+    jenc: float | Jenc | None = None
+    jpipe: float | Jpipe | None = None
+    json: float | JSON | None = None
+    json_converter: float | JSONConverter | None = None
+    json_serializer: float | JSONSerializer | None = None
+    json_token: float | JSONToken | None = None
+    json_writer: float | JSONWriter | None = None
+    top_level_lambda: float | Lambda | None = None
+    lazy: float | Lazy | None = None
+    left: float | Left | None = None
+    let: float | Let | None = None
+    list: float | ListClass | None = None
+    lock: float | Lock | None = None
+    long: float | Long | None = None
+    map: float | Map | None = None
+    metadata_property_handling: float | MetadataPropertyHandling | None = None
+    module: float | Module | None = None
+    mutable: float | Mutable | None = None
+    mutating: float | Mutating | None = None
+    namespace: float | Namespace | None = None
+    native: float | Native | None = None
+    new: float | New | None = None
+    newtonsoft: float | Newtonsoft | None = None
+    nil: float | Nil | None = None
+    no: float | No | None = None
+    noexcept: float | Noexcept | None = None
+    nonatomic: float | Nonatomic | None = None
+    top_level_none: float | UnionNoneNone | None = None
+    none: float | NoneClass | None = None
+    top_level_nonlocal: float | Nonlocal | None = None
+    nonmutating: float | Nonmutating | None = None
+    top_level_not: float | Not | None = None
+    not_eq: float | NotEq | None = None
+    ns_string: float | NSString | None = None
+    null: float | Null | None = None
+    top_level_null: float | NullClass | None = None
+    nullptr: float | Nullptr | None = None
+    number: float | Number | None = None
+    object: float | Object | None = None
+    of: float | Of | None = None
+    oneway: float | Oneway | None = None
+    open: float | Open | None = None
+    operator: float | Operator | None = None
+    optional: float | OptionalClass | None = None
+    top_level_or: float | Or | None = None
+    or_eq: float | OrEq | None = None
+    out: float | Out | None = None
+    override: float | Override | None = None
+    package: float | Package | None = None
+    params: float | Params | None = None
+    top_level_pass: float | Pass | None = None
+    port: float | Port | None = None
+    postfix: float | Postfix | None = None
+    precedence: float | Precedence | None = None
+    prefix: float | Prefix | None = None
+    top_level_print: float | Print | None = None
+    printf: float | Printf | None = None
+    private: float | Private | None = None
+    protected: float | Protected | None = None
+    protocol: float | Protocol | None = None
+    top_level_protocol: float | ProtocolClass | None = None
+    public: float | Public | None = None
+    quicktype: float | Quicktype | None = None
+    top_level_raise: float | Raise | None = None
+    range: float | Range | None = None
+    readonly: float | Readonly | None = None
+    ref: float | Ref | None = None
+    register: float | Register | None = None
+    reinterpret_cast: float | ReinterpretCast | None = None
+    repeat: float | Repeat | None = None
+    require: float | Require | None = None
+    required: float | Required | None = None
+    requires: float | Requires | None = None
+    restrict: float | Restrict | None = None
+    retain: float | Retain | None = None
+    rethrows: float | Rethrows | None = None
+    top_level_return: float | Return | None = None
+    right: float | Right | None = None
+    sbyte: float | Sbyte | None = None
+    sealed: float | Sealed | None = None
+    sel: float | Sel | None = None
+    select: float | Select | None = None
+    top_level_self: float | Self | None = None
+    purple_self: float | SelfClass | None = None
+    serialize: float | Serialize | None = None
+    set: float | Set | None = None
+    short: float | Short | None = None
+    signed: float | Signed | None = None
+    sizeof: float | Sizeof | None = None
+    stackalloc: float | Stackalloc | None = None
+    static: float | Static | None = None
+    static_assert: float | StaticAssert | None = None
+    static_cast: float | StaticCast | None = None
+    strictfp: float | Strictfp | None = None
+    string: float | String | None = None
+    struct: float | Struct | None = None
+    subscript: float | Subscript | None = None
+    super: float | Super | None = None
+    switch: float | Switch | None = None
+    symbol: float | Symbol | None = None
+    synchronized: float | Synchronized | None = None
+    system: float | System | None = None
+    template: float | Template | None = None
+    then: float | Then | None = None
+    this: float | This | None = None
+    thread_local: float | ThreadLocal | None = None
+    throw: float | Throw | None = None
+    throws: float | Throws | None = None
+    to_json: float | ToJSON | None = None
+    top_level: float | TopLevelClass | None = None
+    transient: float | Transient | None = None
+    true: float | TrueClass | None = None
+    top_level_true: float | UnionTrueTrue | None = None
+    top_level_try: float | Try | None = None
+    type: float | TypeClass | None = None
+    top_level_type: float | UnionTypeType | None = None
+    typealias: float | Typealias | None = None
+    typedef: float | Typedef | None = None
+    typeid: float | Typeid | None = None
+    typename: float | Typename | None = None
+    typeof: float | Typeof | None = None
+    uint: float | Uint | None = None
+    ulong: float | Ulong | None = None
+    unchecked: float | Unchecked | None = None
+    undefined: float | Undefined | None = None
+    union: float | UnionClass | None = None
+    unowned: float | Unowned | None = None
+    unsafe: float | Unsafe | None = None
+    unsigned: float | Unsigned | None = None
+    ushort: float | Ushort | None = None
+    using: float | Using | None = None
+    var: float | Var | None = None
+    virtual: float | Virtual | None = None
+    void: float | Void | None = None
+    volatile: float | Volatile | None = None
+    wchar_t: float | WcharT | None = None
+    weak: float | Weak | None = None
+    where: float | Where | None = None
+    top_level_while: float | While | None = None
+    will_set: float | WillSet | None = None
+    top_level_with: float | With | None = None
+    xor: float | Xor | None = None
+    xor_eq: float | XorEq | None = None
+    yes: float | Yes | None = None
+    top_level_yield: float | Yield | None = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TopLevel':
+        assert isinstance(obj, dict)
+        empty = from_union([from_float, Empty.from_dict, from_none], obj.get("_"))
+        purple_bool = from_union([from_float, BoolClass.from_dict, from_none], obj.get("_Bool"))
+        complex = from_union([from_float, Complex.from_dict, from_none], obj.get("_Complex"))
+        imaginery = from_union([from_float, Imaginery.from_dict, from_none], obj.get("_Imaginery"))
+        abstract = from_union([from_float, Abstract.from_dict, from_none], obj.get("abstract"))
+        alignas = from_union([from_float, Alignas.from_dict, from_none], obj.get("alignas"))
+        alignof = from_union([from_float, Alignof.from_dict, from_none], obj.get("alignof"))
+        top_level_and = from_union([from_float, And.from_dict, from_none], obj.get("and"))
+        and_eq = from_union([from_float, AndEq.from_dict, from_none], obj.get("and_eq"))
+        top_level_any = from_union([from_float, UnionAnyAny.from_dict, from_none], obj.get("any"))
+        any = from_union([from_float, AnyClass.from_dict, from_none], obj.get("Any"))
+        array = from_union([from_float, Array.from_dict, from_none], obj.get("array"))
+        top_level_as = from_union([from_float, As.from_dict, from_none], obj.get("as"))
+        asm = from_union([from_float, ASM.from_dict, from_none], obj.get("asm"))
+        top_level_assert = from_union([from_float, Assert.from_dict, from_none], obj.get("assert"))
+        associatedtype = from_union([from_float, Associatedtype.from_dict, from_none], obj.get("associatedtype"))
+        associativity = from_union([from_float, Associativity.from_dict, from_none], obj.get("associativity"))
+        top_level_async = from_union([from_float, Async.from_dict, from_none], obj.get("async"))
+        atomic = from_union([from_float, Atomic.from_dict, from_none], obj.get("atomic"))
+        atomic_cancel = from_union([from_float, AtomicCancel.from_dict, from_none], obj.get("atomic_cancel"))
+        atomic_commit = from_union([from_float, AtomicCommit.from_dict, from_none], obj.get("atomic_commit"))
+        atomic_noexcept = from_union([from_float, AtomicNoexcept.from_dict, from_none], obj.get("atomic_noexcept"))
+        auto = from_union([from_float, Auto.from_dict, from_none], obj.get("auto"))
+        top_level_await = from_union([from_float, Await.from_dict, from_none], obj.get("await"))
+        base = from_union([from_float, Base.from_dict, from_none], obj.get("base"))
+        bitand = from_union([from_float, Bitand.from_dict, from_none], obj.get("bitand"))
+        bitor = from_union([from_float, Bitor.from_dict, from_none], obj.get("bitor"))
+        top_level_bool = from_union([from_float, Bool.from_dict, from_none], obj.get("BOOL"))
+        fluffy_bool = from_union([from_float, UnionBoolBool.from_dict, from_none], obj.get("bool"))
+        boolean = from_union([from_float, Boolean.from_dict, from_none], obj.get("boolean"))
+        top_level_break = from_union([from_float, Break.from_dict, from_none], obj.get("break"))
+        bycopy = from_union([from_float, Bycopy.from_dict, from_none], obj.get("bycopy"))
+        byref = from_union([from_float, Byref.from_dict, from_none], obj.get("byref"))
+        byte = from_union([from_float, Byte.from_dict, from_none], obj.get("byte"))
+        case = from_union([from_float, Case.from_dict, from_none], obj.get("case"))
+        catch = from_union([from_float, Catch.from_dict, from_none], obj.get("catch"))
+        chan = from_union([from_float, Chan.from_dict, from_none], obj.get("chan"))
+        char = from_union([from_float, Char.from_dict, from_none], obj.get("char"))
+        char16_t = from_union([from_float, Char16T.from_dict, from_none], obj.get("char16_t"))
+        char32_t = from_union([from_float, Char32T.from_dict, from_none], obj.get("char32_t"))
+        checked = from_union([from_float, Checked.from_dict, from_none], obj.get("checked"))
+        purple_class = from_union([from_float, ClassClass.from_dict, from_none], obj.get("class"))
+        top_level_class = from_union([from_float, Class.from_dict, from_none], obj.get("Class"))
+        co_await = from_union([from_float, CoAwait.from_dict, from_none], obj.get("co_await"))
+        co_return = from_union([from_float, CoReturn.from_dict, from_none], obj.get("co_return"))
+        co_yield = from_union([from_float, CoYield.from_dict, from_none], obj.get("co_yield"))
+        compl = from_union([from_float, Compl.from_dict, from_none], obj.get("compl"))
+        concept = from_union([from_float, Concept.from_dict, from_none], obj.get("concept"))
+        console = from_union([from_float, Console.from_dict, from_none], obj.get("console"))
+        const = from_union([from_float, Const.from_dict, from_none], obj.get("const"))
+        const_cast = from_union([from_float, ConstCast.from_dict, from_none], obj.get("const_cast"))
+        constexpr = from_union([from_float, Constexpr.from_dict, from_none], obj.get("constexpr"))
+        constructor = from_union([from_float, Constructor.from_dict, from_none], obj.get("constructor"))
+        top_level_continue = from_union([from_float, Continue.from_dict, from_none], obj.get("continue"))
+        convenience = from_union([from_float, Convenience.from_dict, from_none], obj.get("convenience"))
+        convert = from_union([from_float, Convert.from_dict, from_none], obj.get("convert"))
+        converter = from_union([from_float, Converter.from_dict, from_none], obj.get("converter"))
+        date = from_union([from_float, Date.from_dict, from_none], obj.get("date"))
+        date_parse_handling = from_union([from_float, DateParseHandling.from_dict, from_none], obj.get("date_parse_handling"))
+        debugger = from_union([from_float, Debugger.from_dict, from_none], obj.get("debugger"))
+        decimal = from_union([from_float, Decimal.from_dict, from_none], obj.get("decimal"))
+        declare = from_union([from_float, Declare.from_dict, from_none], obj.get("declare"))
+        decltype = from_union([from_float, Decltype.from_dict, from_none], obj.get("decltype"))
+        decode_string = from_union([from_float, DecodeString.from_dict, from_none], obj.get("decode_string"))
+        top_level_def = from_union([from_float, Def.from_dict, from_none], obj.get("def"))
+        default = from_union([from_float, Default.from_dict, from_none], obj.get("default"))
+        defer = from_union([from_float, Defer.from_dict, from_none], obj.get("defer"))
+        deinit = from_union([from_float, Deinit.from_dict, from_none], obj.get("deinit"))
+        top_level_del = from_union([from_float, Del.from_dict, from_none], obj.get("del"))
+        delegate = from_union([from_float, Delegate.from_dict, from_none], obj.get("delegate"))
+        delete = from_union([from_float, Delete.from_dict, from_none], obj.get("delete"))
+        top_level_dict = from_union([from_float, DictClass.from_dict, from_none], obj.get("dict"))
+        dictionary = from_union([from_float, Dictionary.from_dict, from_none], obj.get("dictionary"))
+        did_set = from_union([from_float, DidSet.from_dict, from_none], obj.get("didSet"))
+        do = from_union([from_float, Do.from_dict, from_none], obj.get("do"))
+        double = from_union([from_float, Double.from_dict, from_none], obj.get("double"))
+        dummy = from_union([from_float, from_none], obj.get("dummy"))
+        dynamic = from_union([from_float, Dynamic.from_dict, from_none], obj.get("dynamic"))
+        dynamic_cast = from_union([from_float, DynamicCast.from_dict, from_none], obj.get("dynamic_cast"))
+        top_level_elif = from_union([from_float, Elif.from_dict, from_none], obj.get("elif"))
+        top_level_else = from_union([from_float, Else.from_dict, from_none], obj.get("else"))
+        encode_quick_type = from_union([from_float, EncodeQuickType.from_dict, from_none], obj.get("encode_quick_type"))
+        enum = from_union([from_float, EnumClass.from_dict, from_none], obj.get("enum"))
+        event = from_union([from_float, Event.from_dict, from_none], obj.get("event"))
+        top_level_except = from_union([from_float, Except.from_dict, from_none], obj.get("except"))
+        exception = from_union([from_float, Exception.from_dict, from_none], obj.get("exception"))
+        explicit = from_union([from_float, Explicit.from_dict, from_none], obj.get("explicit"))
+        export = from_union([from_float, Export.from_dict, from_none], obj.get("export"))
+        exposing = from_union([from_float, Exposing.from_dict, from_none], obj.get("exposing"))
+        extends = from_union([from_float, Extends.from_dict, from_none], obj.get("extends"))
+        extension = from_union([from_float, Extension.from_dict, from_none], obj.get("extension"))
+        extern = from_union([from_float, Extern.from_dict, from_none], obj.get("extern"))
+        fallthrough = from_union([from_float, Fallthrough.from_dict, from_none], obj.get("fallthrough"))
+        top_level_false = from_union([from_float, UnionFalseFalse.from_dict, from_none], obj.get("false"))
+        false = from_union([from_float, FalseClass.from_dict, from_none], obj.get("False"))
+        fileprivate = from_union([from_float, Fileprivate.from_dict, from_none], obj.get("fileprivate"))
+        final = from_union([from_float, Final.from_dict, from_none], obj.get("final"))
+        top_level_finally = from_union([from_float, Finally.from_dict, from_none], obj.get("finally"))
+        fixed = from_union([from_float, Fixed.from_dict, from_none], obj.get("fixed"))
+        top_level_float = from_union([from_float, Float.from_dict, from_none], obj.get("float"))
+        top_level_for = from_union([from_float, For.from_dict, from_none], obj.get("for"))
+        foreach = from_union([from_float, Foreach.from_dict, from_none], obj.get("foreach"))
+        friend = from_union([from_float, Friend.from_dict, from_none], obj.get("friend"))
+        top_level_from = from_union([from_float, From.from_dict, from_none], obj.get("from"))
+        from_json = from_union([from_float, FromJSON.from_dict, from_none], obj.get("from_json"))
+        func = from_union([from_float, Func.from_dict, from_none], obj.get("func"))
+        function = from_union([from_float, Function.from_dict, from_none], obj.get("function"))
+        get = from_union([from_float, Get.from_dict, from_none], obj.get("get"))
+        top_level_global = from_union([from_float, Global.from_dict, from_none], obj.get("global"))
+        go = from_union([from_float, Go.from_dict, from_none], obj.get("go"))
+        goto = from_union([from_float, Goto.from_dict, from_none], obj.get("goto"))
+        guard = from_union([from_float, Guard.from_dict, from_none], obj.get("guard"))
+        has_own_property = from_union([from_float, HasOwnProperty.from_dict, from_none], obj.get("hasOwnProperty"))
+        id = from_union([from_float, ID.from_dict, from_none], obj.get("id"))
+        top_level_if = from_union([from_float, If.from_dict, from_none], obj.get("if"))
+        imp = from_union([from_float, Imp.from_dict, from_none], obj.get("IMP"))
+        implements = from_union([from_float, Implements.from_dict, from_none], obj.get("implements"))
+        implicit = from_union([from_float, Implicit.from_dict, from_none], obj.get("implicit"))
+        top_level_import = from_union([from_float, Import.from_dict, from_none], obj.get("import"))
+        top_level_in = from_union([from_float, In.from_dict, from_none], obj.get("in"))
+        indirect = from_union([from_float, Indirect.from_dict, from_none], obj.get("indirect"))
+        infix = from_union([from_float, Infix.from_dict, from_none], obj.get("infix"))
+        init = from_union([from_float, Init.from_dict, from_none], obj.get("init"))
+        inline = from_union([from_float, Inline.from_dict, from_none], obj.get("inline"))
+        inout = from_union([from_float, Inout.from_dict, from_none], obj.get("inout"))
+        instanceof = from_union([from_float, Instanceof.from_dict, from_none], obj.get("instanceof"))
+        top_level_int = from_union([from_float, Int.from_dict, from_none], obj.get("int"))
+        interface = from_union([from_float, Interface.from_dict, from_none], obj.get("interface"))
+        internal = from_union([from_float, Internal.from_dict, from_none], obj.get("internal"))
+        top_level_is = from_union([from_float, Is.from_dict, from_none], obj.get("is"))
+        iterable = from_union([from_float, IterableClass.from_dict, from_none], obj.get("iterable"))
+        jdec = from_union([from_float, Jdec.from_dict, from_none], obj.get("jdec"))
+        jenc = from_union([from_float, Jenc.from_dict, from_none], obj.get("jenc"))
+        jpipe = from_union([from_float, Jpipe.from_dict, from_none], obj.get("jpipe"))
+        json = from_union([from_float, JSON.from_dict, from_none], obj.get("json"))
+        json_converter = from_union([from_float, JSONConverter.from_dict, from_none], obj.get("json_converter"))
+        json_serializer = from_union([from_float, JSONSerializer.from_dict, from_none], obj.get("json_serializer"))
+        json_token = from_union([from_float, JSONToken.from_dict, from_none], obj.get("json_token"))
+        json_writer = from_union([from_float, JSONWriter.from_dict, from_none], obj.get("json_writer"))
+        top_level_lambda = from_union([from_float, Lambda.from_dict, from_none], obj.get("lambda"))
+        lazy = from_union([from_float, Lazy.from_dict, from_none], obj.get("lazy"))
+        left = from_union([from_float, Left.from_dict, from_none], obj.get("left"))
+        let = from_union([from_float, Let.from_dict, from_none], obj.get("let"))
+        list = from_union([from_float, ListClass.from_dict, from_none], obj.get("list"))
+        lock = from_union([from_float, Lock.from_dict, from_none], obj.get("lock"))
+        long = from_union([from_float, Long.from_dict, from_none], obj.get("long"))
+        map = from_union([from_float, Map.from_dict, from_none], obj.get("map"))
+        metadata_property_handling = from_union([from_float, MetadataPropertyHandling.from_dict, from_none], obj.get("metadata_property_handling"))
+        module = from_union([from_float, Module.from_dict, from_none], obj.get("module"))
+        mutable = from_union([from_float, Mutable.from_dict, from_none], obj.get("mutable"))
+        mutating = from_union([from_float, Mutating.from_dict, from_none], obj.get("mutating"))
+        namespace = from_union([from_float, Namespace.from_dict, from_none], obj.get("namespace"))
+        native = from_union([from_float, Native.from_dict, from_none], obj.get("native"))
+        new = from_union([from_float, New.from_dict, from_none], obj.get("new"))
+        newtonsoft = from_union([from_float, Newtonsoft.from_dict, from_none], obj.get("newtonsoft"))
+        nil = from_union([from_float, Nil.from_dict, from_none], obj.get("nil"))
+        no = from_union([from_float, No.from_dict, from_none], obj.get("NO"))
+        noexcept = from_union([from_float, Noexcept.from_dict, from_none], obj.get("noexcept"))
+        nonatomic = from_union([from_float, Nonatomic.from_dict, from_none], obj.get("nonatomic"))
+        top_level_none = from_union([from_float, UnionNoneNone.from_dict, from_none], obj.get("none"))
+        none = from_union([from_float, NoneClass.from_dict, from_none], obj.get("None"))
+        top_level_nonlocal = from_union([from_float, Nonlocal.from_dict, from_none], obj.get("nonlocal"))
+        nonmutating = from_union([from_float, Nonmutating.from_dict, from_none], obj.get("nonmutating"))
+        top_level_not = from_union([from_float, Not.from_dict, from_none], obj.get("not"))
+        not_eq = from_union([from_float, NotEq.from_dict, from_none], obj.get("not_eq"))
+        ns_string = from_union([from_float, NSString.from_dict, from_none], obj.get("NSString"))
+        null = from_union([from_float, Null.from_dict, from_none], obj.get("NULL"))
+        top_level_null = from_union([from_float, NullClass.from_dict, from_none], obj.get("null"))
+        nullptr = from_union([from_float, Nullptr.from_dict, from_none], obj.get("nullptr"))
+        number = from_union([from_float, Number.from_dict, from_none], obj.get("number"))
+        object = from_union([from_float, Object.from_dict, from_none], obj.get("object"))
+        of = from_union([from_float, Of.from_dict, from_none], obj.get("of"))
+        oneway = from_union([from_float, Oneway.from_dict, from_none], obj.get("oneway"))
+        open = from_union([from_float, Open.from_dict, from_none], obj.get("open"))
+        operator = from_union([from_float, Operator.from_dict, from_none], obj.get("operator"))
+        optional = from_union([from_float, OptionalClass.from_dict, from_none], obj.get("optional"))
+        top_level_or = from_union([from_float, Or.from_dict, from_none], obj.get("or"))
+        or_eq = from_union([from_float, OrEq.from_dict, from_none], obj.get("or_eq"))
+        out = from_union([from_float, Out.from_dict, from_none], obj.get("out"))
+        override = from_union([from_float, Override.from_dict, from_none], obj.get("override"))
+        package = from_union([from_float, Package.from_dict, from_none], obj.get("package"))
+        params = from_union([from_float, Params.from_dict, from_none], obj.get("params"))
+        top_level_pass = from_union([from_float, Pass.from_dict, from_none], obj.get("pass"))
+        port = from_union([from_float, Port.from_dict, from_none], obj.get("port"))
+        postfix = from_union([from_float, Postfix.from_dict, from_none], obj.get("postfix"))
+        precedence = from_union([from_float, Precedence.from_dict, from_none], obj.get("precedence"))
+        prefix = from_union([from_float, Prefix.from_dict, from_none], obj.get("prefix"))
+        top_level_print = from_union([from_float, Print.from_dict, from_none], obj.get("print"))
+        printf = from_union([from_float, Printf.from_dict, from_none], obj.get("printf"))
+        private = from_union([from_float, Private.from_dict, from_none], obj.get("private"))
+        protected = from_union([from_float, Protected.from_dict, from_none], obj.get("protected"))
+        protocol = from_union([from_float, Protocol.from_dict, from_none], obj.get("Protocol"))
+        top_level_protocol = from_union([from_float, ProtocolClass.from_dict, from_none], obj.get("protocol"))
+        public = from_union([from_float, Public.from_dict, from_none], obj.get("public"))
+        quicktype = from_union([from_float, Quicktype.from_dict, from_none], obj.get("quicktype"))
+        top_level_raise = from_union([from_float, Raise.from_dict, from_none], obj.get("raise"))
+        range = from_union([from_float, Range.from_dict, from_none], obj.get("range"))
+        readonly = from_union([from_float, Readonly.from_dict, from_none], obj.get("readonly"))
+        ref = from_union([from_float, Ref.from_dict, from_none], obj.get("ref"))
+        register = from_union([from_float, Register.from_dict, from_none], obj.get("register"))
+        reinterpret_cast = from_union([from_float, ReinterpretCast.from_dict, from_none], obj.get("reinterpret_cast"))
+        repeat = from_union([from_float, Repeat.from_dict, from_none], obj.get("repeat"))
+        require = from_union([from_float, Require.from_dict, from_none], obj.get("require"))
+        required = from_union([from_float, Required.from_dict, from_none], obj.get("required"))
+        requires = from_union([from_float, Requires.from_dict, from_none], obj.get("requires"))
+        restrict = from_union([from_float, Restrict.from_dict, from_none], obj.get("restrict"))
+        retain = from_union([from_float, Retain.from_dict, from_none], obj.get("retain"))
+        rethrows = from_union([from_float, Rethrows.from_dict, from_none], obj.get("rethrows"))
+        top_level_return = from_union([from_float, Return.from_dict, from_none], obj.get("return"))
+        right = from_union([from_float, Right.from_dict, from_none], obj.get("right"))
+        sbyte = from_union([from_float, Sbyte.from_dict, from_none], obj.get("sbyte"))
+        sealed = from_union([from_float, Sealed.from_dict, from_none], obj.get("sealed"))
+        sel = from_union([from_float, Sel.from_dict, from_none], obj.get("SEL"))
+        select = from_union([from_float, Select.from_dict, from_none], obj.get("select"))
+        top_level_self = from_union([from_float, Self.from_dict, from_none], obj.get("Self"))
+        purple_self = from_union([from_float, SelfClass.from_dict, from_none], obj.get("self"))
+        serialize = from_union([from_float, Serialize.from_dict, from_none], obj.get("serialize"))
+        set = from_union([from_float, Set.from_dict, from_none], obj.get("set"))
+        short = from_union([from_float, Short.from_dict, from_none], obj.get("short"))
+        signed = from_union([from_float, Signed.from_dict, from_none], obj.get("signed"))
+        sizeof = from_union([from_float, Sizeof.from_dict, from_none], obj.get("sizeof"))
+        stackalloc = from_union([from_float, Stackalloc.from_dict, from_none], obj.get("stackalloc"))
+        static = from_union([from_float, Static.from_dict, from_none], obj.get("static"))
+        static_assert = from_union([from_float, StaticAssert.from_dict, from_none], obj.get("static_assert"))
+        static_cast = from_union([from_float, StaticCast.from_dict, from_none], obj.get("static_cast"))
+        strictfp = from_union([from_float, Strictfp.from_dict, from_none], obj.get("strictfp"))
+        string = from_union([from_float, String.from_dict, from_none], obj.get("string"))
+        struct = from_union([from_float, Struct.from_dict, from_none], obj.get("struct"))
+        subscript = from_union([from_float, Subscript.from_dict, from_none], obj.get("subscript"))
+        super = from_union([from_float, Super.from_dict, from_none], obj.get("super"))
+        switch = from_union([from_float, Switch.from_dict, from_none], obj.get("switch"))
+        symbol = from_union([from_float, Symbol.from_dict, from_none], obj.get("symbol"))
+        synchronized = from_union([from_float, Synchronized.from_dict, from_none], obj.get("synchronized"))
+        system = from_union([from_float, System.from_dict, from_none], obj.get("system"))
+        template = from_union([from_float, Template.from_dict, from_none], obj.get("template"))
+        then = from_union([from_float, Then.from_dict, from_none], obj.get("then"))
+        this = from_union([from_float, This.from_dict, from_none], obj.get("this"))
+        thread_local = from_union([from_float, ThreadLocal.from_dict, from_none], obj.get("thread_local"))
+        throw = from_union([from_float, Throw.from_dict, from_none], obj.get("throw"))
+        throws = from_union([from_float, Throws.from_dict, from_none], obj.get("throws"))
+        to_json = from_union([from_float, ToJSON.from_dict, from_none], obj.get("to_json"))
+        top_level = from_union([from_float, TopLevelClass.from_dict, from_none], obj.get("top_level"))
+        transient = from_union([from_float, Transient.from_dict, from_none], obj.get("transient"))
+        true = from_union([from_float, TrueClass.from_dict, from_none], obj.get("True"))
+        top_level_true = from_union([from_float, UnionTrueTrue.from_dict, from_none], obj.get("true"))
+        top_level_try = from_union([from_float, Try.from_dict, from_none], obj.get("try"))
+        type = from_union([from_float, TypeClass.from_dict, from_none], obj.get("Type"))
+        top_level_type = from_union([from_float, UnionTypeType.from_dict, from_none], obj.get("type"))
+        typealias = from_union([from_float, Typealias.from_dict, from_none], obj.get("typealias"))
+        typedef = from_union([from_float, Typedef.from_dict, from_none], obj.get("typedef"))
+        typeid = from_union([from_float, Typeid.from_dict, from_none], obj.get("typeid"))
+        typename = from_union([from_float, Typename.from_dict, from_none], obj.get("typename"))
+        typeof = from_union([from_float, Typeof.from_dict, from_none], obj.get("typeof"))
+        uint = from_union([from_float, Uint.from_dict, from_none], obj.get("uint"))
+        ulong = from_union([from_float, Ulong.from_dict, from_none], obj.get("ulong"))
+        unchecked = from_union([from_float, Unchecked.from_dict, from_none], obj.get("unchecked"))
+        undefined = from_union([from_float, Undefined.from_dict, from_none], obj.get("undefined"))
+        union = from_union([from_float, UnionClass.from_dict, from_none], obj.get("union"))
+        unowned = from_union([from_float, Unowned.from_dict, from_none], obj.get("unowned"))
+        unsafe = from_union([from_float, Unsafe.from_dict, from_none], obj.get("unsafe"))
+        unsigned = from_union([from_float, Unsigned.from_dict, from_none], obj.get("unsigned"))
+        ushort = from_union([from_float, Ushort.from_dict, from_none], obj.get("ushort"))
+        using = from_union([from_float, Using.from_dict, from_none], obj.get("using"))
+        var = from_union([from_float, Var.from_dict, from_none], obj.get("var"))
+        virtual = from_union([from_float, Virtual.from_dict, from_none], obj.get("virtual"))
+        void = from_union([from_float, Void.from_dict, from_none], obj.get("void"))
+        volatile = from_union([from_float, Volatile.from_dict, from_none], obj.get("volatile"))
+        wchar_t = from_union([from_float, WcharT.from_dict, from_none], obj.get("wchar_t"))
+        weak = from_union([from_float, Weak.from_dict, from_none], obj.get("weak"))
+        where = from_union([from_float, Where.from_dict, from_none], obj.get("where"))
+        top_level_while = from_union([from_float, While.from_dict, from_none], obj.get("while"))
+        will_set = from_union([from_float, WillSet.from_dict, from_none], obj.get("willSet"))
+        top_level_with = from_union([from_float, With.from_dict, from_none], obj.get("with"))
+        xor = from_union([from_float, Xor.from_dict, from_none], obj.get("xor"))
+        xor_eq = from_union([from_float, XorEq.from_dict, from_none], obj.get("xor_eq"))
+        yes = from_union([from_float, Yes.from_dict, from_none], obj.get("YES"))
+        top_level_yield = from_union([from_float, Yield.from_dict, from_none], obj.get("yield"))
+        return TopLevel(empty, purple_bool, complex, imaginery, abstract, alignas, alignof, top_level_and, and_eq, top_level_any, any, array, top_level_as, asm, top_level_assert, associatedtype, associativity, top_level_async, atomic, atomic_cancel, atomic_commit, atomic_noexcept, auto, top_level_await, base, bitand, bitor, top_level_bool, fluffy_bool, boolean, top_level_break, bycopy, byref, byte, case, catch, chan, char, char16_t, char32_t, checked, purple_class, top_level_class, co_await, co_return, co_yield, compl, concept, console, const, const_cast, constexpr, constructor, top_level_continue, convenience, convert, converter, date, date_parse_handling, debugger, decimal, declare, decltype, decode_string, top_level_def, default, defer, deinit, top_level_del, delegate, delete, top_level_dict, dictionary, did_set, do, double, dummy, dynamic, dynamic_cast, top_level_elif, top_level_else, encode_quick_type, enum, event, top_level_except, exception, explicit, export, exposing, extends, extension, extern, fallthrough, top_level_false, false, fileprivate, final, top_level_finally, fixed, top_level_float, top_level_for, foreach, friend, top_level_from, from_json, func, function, get, top_level_global, go, goto, guard, has_own_property, id, top_level_if, imp, implements, implicit, top_level_import, top_level_in, indirect, infix, init, inline, inout, instanceof, top_level_int, interface, internal, top_level_is, iterable, jdec, jenc, jpipe, json, json_converter, json_serializer, json_token, json_writer, top_level_lambda, lazy, left, let, list, lock, long, map, metadata_property_handling, module, mutable, mutating, namespace, native, new, newtonsoft, nil, no, noexcept, nonatomic, top_level_none, none, top_level_nonlocal, nonmutating, top_level_not, not_eq, ns_string, null, top_level_null, nullptr, number, object, of, oneway, open, operator, optional, top_level_or, or_eq, out, override, package, params, top_level_pass, port, postfix, precedence, prefix, top_level_print, printf, private, protected, protocol, top_level_protocol, public, quicktype, top_level_raise, range, readonly, ref, register, reinterpret_cast, repeat, require, required, requires, restrict, retain, rethrows, top_level_return, right, sbyte, sealed, sel, select, top_level_self, purple_self, serialize, set, short, signed, sizeof, stackalloc, static, static_assert, static_cast, strictfp, string, struct, subscript, super, switch, symbol, synchronized, system, template, then, this, thread_local, throw, throws, to_json, top_level, transient, true, top_level_true, top_level_try, type, top_level_type, typealias, typedef, typeid, typename, typeof, uint, ulong, unchecked, undefined, union, unowned, unsafe, unsigned, ushort, using, var, virtual, void, volatile, wchar_t, weak, where, top_level_while, will_set, top_level_with, xor, xor_eq, yes, top_level_yield)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.empty is not None:
+            result["_"] = from_union([to_float, lambda x: to_class(Empty, x), from_none], self.empty)
+        if self.purple_bool is not None:
+            result["_Bool"] = from_union([to_float, lambda x: to_class(BoolClass, x), from_none], self.purple_bool)
+        if self.complex is not None:
+            result["_Complex"] = from_union([to_float, lambda x: to_class(Complex, x), from_none], self.complex)
+        if self.imaginery is not None:
+            result["_Imaginery"] = from_union([to_float, lambda x: to_class(Imaginery, x), from_none], self.imaginery)
+        if self.abstract is not None:
+            result["abstract"] = from_union([to_float, lambda x: to_class(Abstract, x), from_none], self.abstract)
+        if self.alignas is not None:
+            result["alignas"] = from_union([to_float, lambda x: to_class(Alignas, x), from_none], self.alignas)
+        if self.alignof is not None:
+            result["alignof"] = from_union([to_float, lambda x: to_class(Alignof, x), from_none], self.alignof)
+        if self.top_level_and is not None:
+            result["and"] = from_union([to_float, lambda x: to_class(And, x), from_none], self.top_level_and)
+        if self.and_eq is not None:
+            result["and_eq"] = from_union([to_float, lambda x: to_class(AndEq, x), from_none], self.and_eq)
+        if self.top_level_any is not None:
+            result["any"] = from_union([to_float, lambda x: to_class(UnionAnyAny, x), from_none], self.top_level_any)
+        if self.any is not None:
+            result["Any"] = from_union([to_float, lambda x: to_class(AnyClass, x), from_none], self.any)
+        if self.array is not None:
+            result["array"] = from_union([to_float, lambda x: to_class(Array, x), from_none], self.array)
+        if self.top_level_as is not None:
+            result["as"] = from_union([to_float, lambda x: to_class(As, x), from_none], self.top_level_as)
+        if self.asm is not None:
+            result["asm"] = from_union([to_float, lambda x: to_class(ASM, x), from_none], self.asm)
+        if self.top_level_assert is not None:
+            result["assert"] = from_union([to_float, lambda x: to_class(Assert, x), from_none], self.top_level_assert)
+        if self.associatedtype is not None:
+            result["associatedtype"] = from_union([to_float, lambda x: to_class(Associatedtype, x), from_none], self.associatedtype)
+        if self.associativity is not None:
+            result["associativity"] = from_union([to_float, lambda x: to_class(Associativity, x), from_none], self.associativity)
+        if self.top_level_async is not None:
+            result["async"] = from_union([to_float, lambda x: to_class(Async, x), from_none], self.top_level_async)
+        if self.atomic is not None:
+            result["atomic"] = from_union([to_float, lambda x: to_class(Atomic, x), from_none], self.atomic)
+        if self.atomic_cancel is not None:
+            result["atomic_cancel"] = from_union([to_float, lambda x: to_class(AtomicCancel, x), from_none], self.atomic_cancel)
+        if self.atomic_commit is not None:
+            result["atomic_commit"] = from_union([to_float, lambda x: to_class(AtomicCommit, x), from_none], self.atomic_commit)
+        if self.atomic_noexcept is not None:
+            result["atomic_noexcept"] = from_union([to_float, lambda x: to_class(AtomicNoexcept, x), from_none], self.atomic_noexcept)
+        if self.auto is not None:
+            result["auto"] = from_union([to_float, lambda x: to_class(Auto, x), from_none], self.auto)
+        if self.top_level_await is not None:
+            result["await"] = from_union([to_float, lambda x: to_class(Await, x), from_none], self.top_level_await)
+        if self.base is not None:
+            result["base"] = from_union([to_float, lambda x: to_class(Base, x), from_none], self.base)
+        if self.bitand is not None:
+            result["bitand"] = from_union([to_float, lambda x: to_class(Bitand, x), from_none], self.bitand)
+        if self.bitor is not None:
+            result["bitor"] = from_union([to_float, lambda x: to_class(Bitor, x), from_none], self.bitor)
+        if self.top_level_bool is not None:
+            result["BOOL"] = from_union([to_float, lambda x: to_class(Bool, x), from_none], self.top_level_bool)
+        if self.fluffy_bool is not None:
+            result["bool"] = from_union([to_float, lambda x: to_class(UnionBoolBool, x), from_none], self.fluffy_bool)
+        if self.boolean is not None:
+            result["boolean"] = from_union([to_float, lambda x: to_class(Boolean, x), from_none], self.boolean)
+        if self.top_level_break is not None:
+            result["break"] = from_union([to_float, lambda x: to_class(Break, x), from_none], self.top_level_break)
+        if self.bycopy is not None:
+            result["bycopy"] = from_union([to_float, lambda x: to_class(Bycopy, x), from_none], self.bycopy)
+        if self.byref is not None:
+            result["byref"] = from_union([to_float, lambda x: to_class(Byref, x), from_none], self.byref)
+        if self.byte is not None:
+            result["byte"] = from_union([to_float, lambda x: to_class(Byte, x), from_none], self.byte)
+        if self.case is not None:
+            result["case"] = from_union([to_float, lambda x: to_class(Case, x), from_none], self.case)
+        if self.catch is not None:
+            result["catch"] = from_union([to_float, lambda x: to_class(Catch, x), from_none], self.catch)
+        if self.chan is not None:
+            result["chan"] = from_union([to_float, lambda x: to_class(Chan, x), from_none], self.chan)
+        if self.char is not None:
+            result["char"] = from_union([to_float, lambda x: to_class(Char, x), from_none], self.char)
+        if self.char16_t is not None:
+            result["char16_t"] = from_union([to_float, lambda x: to_class(Char16T, x), from_none], self.char16_t)
+        if self.char32_t is not None:
+            result["char32_t"] = from_union([to_float, lambda x: to_class(Char32T, x), from_none], self.char32_t)
+        if self.checked is not None:
+            result["checked"] = from_union([to_float, lambda x: to_class(Checked, x), from_none], self.checked)
+        if self.purple_class is not None:
+            result["class"] = from_union([to_float, lambda x: to_class(ClassClass, x), from_none], self.purple_class)
+        if self.top_level_class is not None:
+            result["Class"] = from_union([to_float, lambda x: to_class(Class, x), from_none], self.top_level_class)
+        if self.co_await is not None:
+            result["co_await"] = from_union([to_float, lambda x: to_class(CoAwait, x), from_none], self.co_await)
+        if self.co_return is not None:
+            result["co_return"] = from_union([to_float, lambda x: to_class(CoReturn, x), from_none], self.co_return)
+        if self.co_yield is not None:
+            result["co_yield"] = from_union([to_float, lambda x: to_class(CoYield, x), from_none], self.co_yield)
+        if self.compl is not None:
+            result["compl"] = from_union([to_float, lambda x: to_class(Compl, x), from_none], self.compl)
+        if self.concept is not None:
+            result["concept"] = from_union([to_float, lambda x: to_class(Concept, x), from_none], self.concept)
+        if self.console is not None:
+            result["console"] = from_union([to_float, lambda x: to_class(Console, x), from_none], self.console)
+        if self.const is not None:
+            result["const"] = from_union([to_float, lambda x: to_class(Const, x), from_none], self.const)
+        if self.const_cast is not None:
+            result["const_cast"] = from_union([to_float, lambda x: to_class(ConstCast, x), from_none], self.const_cast)
+        if self.constexpr is not None:
+            result["constexpr"] = from_union([to_float, lambda x: to_class(Constexpr, x), from_none], self.constexpr)
+        if self.constructor is not None:
+            result["constructor"] = from_union([to_float, lambda x: to_class(Constructor, x), from_none], self.constructor)
+        if self.top_level_continue is not None:
+            result["continue"] = from_union([to_float, lambda x: to_class(Continue, x), from_none], self.top_level_continue)
+        if self.convenience is not None:
+            result["convenience"] = from_union([to_float, lambda x: to_class(Convenience, x), from_none], self.convenience)
+        if self.convert is not None:
+            result["convert"] = from_union([to_float, lambda x: to_class(Convert, x), from_none], self.convert)
+        if self.converter is not None:
+            result["converter"] = from_union([to_float, lambda x: to_class(Converter, x), from_none], self.converter)
+        if self.date is not None:
+            result["date"] = from_union([to_float, lambda x: to_class(Date, x), from_none], self.date)
+        if self.date_parse_handling is not None:
+            result["date_parse_handling"] = from_union([to_float, lambda x: to_class(DateParseHandling, x), from_none], self.date_parse_handling)
+        if self.debugger is not None:
+            result["debugger"] = from_union([to_float, lambda x: to_class(Debugger, x), from_none], self.debugger)
+        if self.decimal is not None:
+            result["decimal"] = from_union([to_float, lambda x: to_class(Decimal, x), from_none], self.decimal)
+        if self.declare is not None:
+            result["declare"] = from_union([to_float, lambda x: to_class(Declare, x), from_none], self.declare)
+        if self.decltype is not None:
+            result["decltype"] = from_union([to_float, lambda x: to_class(Decltype, x), from_none], self.decltype)
+        if self.decode_string is not None:
+            result["decode_string"] = from_union([to_float, lambda x: to_class(DecodeString, x), from_none], self.decode_string)
+        if self.top_level_def is not None:
+            result["def"] = from_union([to_float, lambda x: to_class(Def, x), from_none], self.top_level_def)
+        if self.default is not None:
+            result["default"] = from_union([to_float, lambda x: to_class(Default, x), from_none], self.default)
+        if self.defer is not None:
+            result["defer"] = from_union([to_float, lambda x: to_class(Defer, x), from_none], self.defer)
+        if self.deinit is not None:
+            result["deinit"] = from_union([to_float, lambda x: to_class(Deinit, x), from_none], self.deinit)
+        if self.top_level_del is not None:
+            result["del"] = from_union([to_float, lambda x: to_class(Del, x), from_none], self.top_level_del)
+        if self.delegate is not None:
+            result["delegate"] = from_union([to_float, lambda x: to_class(Delegate, x), from_none], self.delegate)
+        if self.delete is not None:
+            result["delete"] = from_union([to_float, lambda x: to_class(Delete, x), from_none], self.delete)
+        if self.top_level_dict is not None:
+            result["dict"] = from_union([to_float, lambda x: to_class(DictClass, x), from_none], self.top_level_dict)
+        if self.dictionary is not None:
+            result["dictionary"] = from_union([to_float, lambda x: to_class(Dictionary, x), from_none], self.dictionary)
+        if self.did_set is not None:
+            result["didSet"] = from_union([to_float, lambda x: to_class(DidSet, x), from_none], self.did_set)
+        if self.do is not None:
+            result["do"] = from_union([to_float, lambda x: to_class(Do, x), from_none], self.do)
+        if self.double is not None:
+            result["double"] = from_union([to_float, lambda x: to_class(Double, x), from_none], self.double)
+        if self.dummy is not None:
+            result["dummy"] = from_union([to_float, from_none], self.dummy)
+        if self.dynamic is not None:
+            result["dynamic"] = from_union([to_float, lambda x: to_class(Dynamic, x), from_none], self.dynamic)
+        if self.dynamic_cast is not None:
+            result["dynamic_cast"] = from_union([to_float, lambda x: to_class(DynamicCast, x), from_none], self.dynamic_cast)
+        if self.top_level_elif is not None:
+            result["elif"] = from_union([to_float, lambda x: to_class(Elif, x), from_none], self.top_level_elif)
+        if self.top_level_else is not None:
+            result["else"] = from_union([to_float, lambda x: to_class(Else, x), from_none], self.top_level_else)
+        if self.encode_quick_type is not None:
+            result["encode_quick_type"] = from_union([to_float, lambda x: to_class(EncodeQuickType, x), from_none], self.encode_quick_type)
+        if self.enum is not None:
+            result["enum"] = from_union([to_float, lambda x: to_class(EnumClass, x), from_none], self.enum)
+        if self.event is not None:
+            result["event"] = from_union([to_float, lambda x: to_class(Event, x), from_none], self.event)
+        if self.top_level_except is not None:
+            result["except"] = from_union([to_float, lambda x: to_class(Except, x), from_none], self.top_level_except)
+        if self.exception is not None:
+            result["exception"] = from_union([to_float, lambda x: to_class(Exception, x), from_none], self.exception)
+        if self.explicit is not None:
+            result["explicit"] = from_union([to_float, lambda x: to_class(Explicit, x), from_none], self.explicit)
+        if self.export is not None:
+            result["export"] = from_union([to_float, lambda x: to_class(Export, x), from_none], self.export)
+        if self.exposing is not None:
+            result["exposing"] = from_union([to_float, lambda x: to_class(Exposing, x), from_none], self.exposing)
+        if self.extends is not None:
+            result["extends"] = from_union([to_float, lambda x: to_class(Extends, x), from_none], self.extends)
+        if self.extension is not None:
+            result["extension"] = from_union([to_float, lambda x: to_class(Extension, x), from_none], self.extension)
+        if self.extern is not None:
+            result["extern"] = from_union([to_float, lambda x: to_class(Extern, x), from_none], self.extern)
+        if self.fallthrough is not None:
+            result["fallthrough"] = from_union([to_float, lambda x: to_class(Fallthrough, x), from_none], self.fallthrough)
+        if self.top_level_false is not None:
+            result["false"] = from_union([to_float, lambda x: to_class(UnionFalseFalse, x), from_none], self.top_level_false)
+        if self.false is not None:
+            result["False"] = from_union([to_float, lambda x: to_class(FalseClass, x), from_none], self.false)
+        if self.fileprivate is not None:
+            result["fileprivate"] = from_union([to_float, lambda x: to_class(Fileprivate, x), from_none], self.fileprivate)
+        if self.final is not None:
+            result["final"] = from_union([to_float, lambda x: to_class(Final, x), from_none], self.final)
+        if self.top_level_finally is not None:
+            result["finally"] = from_union([to_float, lambda x: to_class(Finally, x), from_none], self.top_level_finally)
+        if self.fixed is not None:
+            result["fixed"] = from_union([to_float, lambda x: to_class(Fixed, x), from_none], self.fixed)
+        if self.top_level_float is not None:
+            result["float"] = from_union([to_float, lambda x: to_class(Float, x), from_none], self.top_level_float)
+        if self.top_level_for is not None:
+            result["for"] = from_union([to_float, lambda x: to_class(For, x), from_none], self.top_level_for)
+        if self.foreach is not None:
+            result["foreach"] = from_union([to_float, lambda x: to_class(Foreach, x), from_none], self.foreach)
+        if self.friend is not None:
+            result["friend"] = from_union([to_float, lambda x: to_class(Friend, x), from_none], self.friend)
+        if self.top_level_from is not None:
+            result["from"] = from_union([to_float, lambda x: to_class(From, x), from_none], self.top_level_from)
+        if self.from_json is not None:
+            result["from_json"] = from_union([to_float, lambda x: to_class(FromJSON, x), from_none], self.from_json)
+        if self.func is not None:
+            result["func"] = from_union([to_float, lambda x: to_class(Func, x), from_none], self.func)
+        if self.function is not None:
+            result["function"] = from_union([to_float, lambda x: to_class(Function, x), from_none], self.function)
+        if self.get is not None:
+            result["get"] = from_union([to_float, lambda x: to_class(Get, x), from_none], self.get)
+        if self.top_level_global is not None:
+            result["global"] = from_union([to_float, lambda x: to_class(Global, x), from_none], self.top_level_global)
+        if self.go is not None:
+            result["go"] = from_union([to_float, lambda x: to_class(Go, x), from_none], self.go)
+        if self.goto is not None:
+            result["goto"] = from_union([to_float, lambda x: to_class(Goto, x), from_none], self.goto)
+        if self.guard is not None:
+            result["guard"] = from_union([to_float, lambda x: to_class(Guard, x), from_none], self.guard)
+        if self.has_own_property is not None:
+            result["hasOwnProperty"] = from_union([to_float, lambda x: to_class(HasOwnProperty, x), from_none], self.has_own_property)
+        if self.id is not None:
+            result["id"] = from_union([to_float, lambda x: to_class(ID, x), from_none], self.id)
+        if self.top_level_if is not None:
+            result["if"] = from_union([to_float, lambda x: to_class(If, x), from_none], self.top_level_if)
+        if self.imp is not None:
+            result["IMP"] = from_union([to_float, lambda x: to_class(Imp, x), from_none], self.imp)
+        if self.implements is not None:
+            result["implements"] = from_union([to_float, lambda x: to_class(Implements, x), from_none], self.implements)
+        if self.implicit is not None:
+            result["implicit"] = from_union([to_float, lambda x: to_class(Implicit, x), from_none], self.implicit)
+        if self.top_level_import is not None:
+            result["import"] = from_union([to_float, lambda x: to_class(Import, x), from_none], self.top_level_import)
+        if self.top_level_in is not None:
+            result["in"] = from_union([to_float, lambda x: to_class(In, x), from_none], self.top_level_in)
+        if self.indirect is not None:
+            result["indirect"] = from_union([to_float, lambda x: to_class(Indirect, x), from_none], self.indirect)
+        if self.infix is not None:
+            result["infix"] = from_union([to_float, lambda x: to_class(Infix, x), from_none], self.infix)
+        if self.init is not None:
+            result["init"] = from_union([to_float, lambda x: to_class(Init, x), from_none], self.init)
+        if self.inline is not None:
+            result["inline"] = from_union([to_float, lambda x: to_class(Inline, x), from_none], self.inline)
+        if self.inout is not None:
+            result["inout"] = from_union([to_float, lambda x: to_class(Inout, x), from_none], self.inout)
+        if self.instanceof is not None:
+            result["instanceof"] = from_union([to_float, lambda x: to_class(Instanceof, x), from_none], self.instanceof)
+        if self.top_level_int is not None:
+            result["int"] = from_union([to_float, lambda x: to_class(Int, x), from_none], self.top_level_int)
+        if self.interface is not None:
+            result["interface"] = from_union([to_float, lambda x: to_class(Interface, x), from_none], self.interface)
+        if self.internal is not None:
+            result["internal"] = from_union([to_float, lambda x: to_class(Internal, x), from_none], self.internal)
+        if self.top_level_is is not None:
+            result["is"] = from_union([to_float, lambda x: to_class(Is, x), from_none], self.top_level_is)
+        if self.iterable is not None:
+            result["iterable"] = from_union([to_float, lambda x: to_class(IterableClass, x), from_none], self.iterable)
+        if self.jdec is not None:
+            result["jdec"] = from_union([to_float, lambda x: to_class(Jdec, x), from_none], self.jdec)
+        if self.jenc is not None:
+            result["jenc"] = from_union([to_float, lambda x: to_class(Jenc, x), from_none], self.jenc)
+        if self.jpipe is not None:
+            result["jpipe"] = from_union([to_float, lambda x: to_class(Jpipe, x), from_none], self.jpipe)
+        if self.json is not None:
+            result["json"] = from_union([to_float, lambda x: to_class(JSON, x), from_none], self.json)
+        if self.json_converter is not None:
+            result["json_converter"] = from_union([to_float, lambda x: to_class(JSONConverter, x), from_none], self.json_converter)
+        if self.json_serializer is not None:
+            result["json_serializer"] = from_union([to_float, lambda x: to_class(JSONSerializer, x), from_none], self.json_serializer)
+        if self.json_token is not None:
+            result["json_token"] = from_union([to_float, lambda x: to_class(JSONToken, x), from_none], self.json_token)
+        if self.json_writer is not None:
+            result["json_writer"] = from_union([to_float, lambda x: to_class(JSONWriter, x), from_none], self.json_writer)
+        if self.top_level_lambda is not None:
+            result["lambda"] = from_union([to_float, lambda x: to_class(Lambda, x), from_none], self.top_level_lambda)
+        if self.lazy is not None:
+            result["lazy"] = from_union([to_float, lambda x: to_class(Lazy, x), from_none], self.lazy)
+        if self.left is not None:
+            result["left"] = from_union([to_float, lambda x: to_class(Left, x), from_none], self.left)
+        if self.let is not None:
+            result["let"] = from_union([to_float, lambda x: to_class(Let, x), from_none], self.let)
+        if self.list is not None:
+            result["list"] = from_union([to_float, lambda x: to_class(ListClass, x), from_none], self.list)
+        if self.lock is not None:
+            result["lock"] = from_union([to_float, lambda x: to_class(Lock, x), from_none], self.lock)
+        if self.long is not None:
+            result["long"] = from_union([to_float, lambda x: to_class(Long, x), from_none], self.long)
+        if self.map is not None:
+            result["map"] = from_union([to_float, lambda x: to_class(Map, x), from_none], self.map)
+        if self.metadata_property_handling is not None:
+            result["metadata_property_handling"] = from_union([to_float, lambda x: to_class(MetadataPropertyHandling, x), from_none], self.metadata_property_handling)
+        if self.module is not None:
+            result["module"] = from_union([to_float, lambda x: to_class(Module, x), from_none], self.module)
+        if self.mutable is not None:
+            result["mutable"] = from_union([to_float, lambda x: to_class(Mutable, x), from_none], self.mutable)
+        if self.mutating is not None:
+            result["mutating"] = from_union([to_float, lambda x: to_class(Mutating, x), from_none], self.mutating)
+        if self.namespace is not None:
+            result["namespace"] = from_union([to_float, lambda x: to_class(Namespace, x), from_none], self.namespace)
+        if self.native is not None:
+            result["native"] = from_union([to_float, lambda x: to_class(Native, x), from_none], self.native)
+        if self.new is not None:
+            result["new"] = from_union([to_float, lambda x: to_class(New, x), from_none], self.new)
+        if self.newtonsoft is not None:
+            result["newtonsoft"] = from_union([to_float, lambda x: to_class(Newtonsoft, x), from_none], self.newtonsoft)
+        if self.nil is not None:
+            result["nil"] = from_union([to_float, lambda x: to_class(Nil, x), from_none], self.nil)
+        if self.no is not None:
+            result["NO"] = from_union([to_float, lambda x: to_class(No, x), from_none], self.no)
+        if self.noexcept is not None:
+            result["noexcept"] = from_union([to_float, lambda x: to_class(Noexcept, x), from_none], self.noexcept)
+        if self.nonatomic is not None:
+            result["nonatomic"] = from_union([to_float, lambda x: to_class(Nonatomic, x), from_none], self.nonatomic)
+        if self.top_level_none is not None:
+            result["none"] = from_union([to_float, lambda x: to_class(UnionNoneNone, x), from_none], self.top_level_none)
+        if self.none is not None:
+            result["None"] = from_union([to_float, lambda x: to_class(NoneClass, x), from_none], self.none)
+        if self.top_level_nonlocal is not None:
+            result["nonlocal"] = from_union([to_float, lambda x: to_class(Nonlocal, x), from_none], self.top_level_nonlocal)
+        if self.nonmutating is not None:
+            result["nonmutating"] = from_union([to_float, lambda x: to_class(Nonmutating, x), from_none], self.nonmutating)
+        if self.top_level_not is not None:
+            result["not"] = from_union([to_float, lambda x: to_class(Not, x), from_none], self.top_level_not)
+        if self.not_eq is not None:
+            result["not_eq"] = from_union([to_float, lambda x: to_class(NotEq, x), from_none], self.not_eq)
+        if self.ns_string is not None:
+            result["NSString"] = from_union([to_float, lambda x: to_class(NSString, x), from_none], self.ns_string)
+        if self.null is not None:
+            result["NULL"] = from_union([to_float, lambda x: to_class(Null, x), from_none], self.null)
+        if self.top_level_null is not None:
+            result["null"] = from_union([to_float, lambda x: to_class(NullClass, x), from_none], self.top_level_null)
+        if self.nullptr is not None:
+            result["nullptr"] = from_union([to_float, lambda x: to_class(Nullptr, x), from_none], self.nullptr)
+        if self.number is not None:
+            result["number"] = from_union([to_float, lambda x: to_class(Number, x), from_none], self.number)
+        if self.object is not None:
+            result["object"] = from_union([to_float, lambda x: to_class(Object, x), from_none], self.object)
+        if self.of is not None:
+            result["of"] = from_union([to_float, lambda x: to_class(Of, x), from_none], self.of)
+        if self.oneway is not None:
+            result["oneway"] = from_union([to_float, lambda x: to_class(Oneway, x), from_none], self.oneway)
+        if self.open is not None:
+            result["open"] = from_union([to_float, lambda x: to_class(Open, x), from_none], self.open)
+        if self.operator is not None:
+            result["operator"] = from_union([to_float, lambda x: to_class(Operator, x), from_none], self.operator)
+        if self.optional is not None:
+            result["optional"] = from_union([to_float, lambda x: to_class(OptionalClass, x), from_none], self.optional)
+        if self.top_level_or is not None:
+            result["or"] = from_union([to_float, lambda x: to_class(Or, x), from_none], self.top_level_or)
+        if self.or_eq is not None:
+            result["or_eq"] = from_union([to_float, lambda x: to_class(OrEq, x), from_none], self.or_eq)
+        if self.out is not None:
+            result["out"] = from_union([to_float, lambda x: to_class(Out, x), from_none], self.out)
+        if self.override is not None:
+            result["override"] = from_union([to_float, lambda x: to_class(Override, x), from_none], self.override)
+        if self.package is not None:
+            result["package"] = from_union([to_float, lambda x: to_class(Package, x), from_none], self.package)
+        if self.params is not None:
+            result["params"] = from_union([to_float, lambda x: to_class(Params, x), from_none], self.params)
+        if self.top_level_pass is not None:
+            result["pass"] = from_union([to_float, lambda x: to_class(Pass, x), from_none], self.top_level_pass)
+        if self.port is not None:
+            result["port"] = from_union([to_float, lambda x: to_class(Port, x), from_none], self.port)
+        if self.postfix is not None:
+            result["postfix"] = from_union([to_float, lambda x: to_class(Postfix, x), from_none], self.postfix)
+        if self.precedence is not None:
+            result["precedence"] = from_union([to_float, lambda x: to_class(Precedence, x), from_none], self.precedence)
+        if self.prefix is not None:
+            result["prefix"] = from_union([to_float, lambda x: to_class(Prefix, x), from_none], self.prefix)
+        if self.top_level_print is not None:
+            result["print"] = from_union([to_float, lambda x: to_class(Print, x), from_none], self.top_level_print)
+        if self.printf is not None:
+            result["printf"] = from_union([to_float, lambda x: to_class(Printf, x), from_none], self.printf)
+        if self.private is not None:
+            result["private"] = from_union([to_float, lambda x: to_class(Private, x), from_none], self.private)
+        if self.protected is not None:
+            result["protected"] = from_union([to_float, lambda x: to_class(Protected, x), from_none], self.protected)
+        if self.protocol is not None:
+            result["Protocol"] = from_union([to_float, lambda x: to_class(Protocol, x), from_none], self.protocol)
+        if self.top_level_protocol is not None:
+            result["protocol"] = from_union([to_float, lambda x: to_class(ProtocolClass, x), from_none], self.top_level_protocol)
+        if self.public is not None:
+            result["public"] = from_union([to_float, lambda x: to_class(Public, x), from_none], self.public)
+        if self.quicktype is not None:
+            result["quicktype"] = from_union([to_float, lambda x: to_class(Quicktype, x), from_none], self.quicktype)
+        if self.top_level_raise is not None:
+            result["raise"] = from_union([to_float, lambda x: to_class(Raise, x), from_none], self.top_level_raise)
+        if self.range is not None:
+            result["range"] = from_union([to_float, lambda x: to_class(Range, x), from_none], self.range)
+        if self.readonly is not None:
+            result["readonly"] = from_union([to_float, lambda x: to_class(Readonly, x), from_none], self.readonly)
+        if self.ref is not None:
+            result["ref"] = from_union([to_float, lambda x: to_class(Ref, x), from_none], self.ref)
+        if self.register is not None:
+            result["register"] = from_union([to_float, lambda x: to_class(Register, x), from_none], self.register)
+        if self.reinterpret_cast is not None:
+            result["reinterpret_cast"] = from_union([to_float, lambda x: to_class(ReinterpretCast, x), from_none], self.reinterpret_cast)
+        if self.repeat is not None:
+            result["repeat"] = from_union([to_float, lambda x: to_class(Repeat, x), from_none], self.repeat)
+        if self.require is not None:
+            result["require"] = from_union([to_float, lambda x: to_class(Require, x), from_none], self.require)
+        if self.required is not None:
+            result["required"] = from_union([to_float, lambda x: to_class(Required, x), from_none], self.required)
+        if self.requires is not None:
+            result["requires"] = from_union([to_float, lambda x: to_class(Requires, x), from_none], self.requires)
+        if self.restrict is not None:
+            result["restrict"] = from_union([to_float, lambda x: to_class(Restrict, x), from_none], self.restrict)
+        if self.retain is not None:
+            result["retain"] = from_union([to_float, lambda x: to_class(Retain, x), from_none], self.retain)
+        if self.rethrows is not None:
+            result["rethrows"] = from_union([to_float, lambda x: to_class(Rethrows, x), from_none], self.rethrows)
+        if self.top_level_return is not None:
+            result["return"] = from_union([to_float, lambda x: to_class(Return, x), from_none], self.top_level_return)
+        if self.right is not None:
+            result["right"] = from_union([to_float, lambda x: to_class(Right, x), from_none], self.right)
+        if self.sbyte is not None:
+            result["sbyte"] = from_union([to_float, lambda x: to_class(Sbyte, x), from_none], self.sbyte)
+        if self.sealed is not None:
+            result["sealed"] = from_union([to_float, lambda x: to_class(Sealed, x), from_none], self.sealed)
+        if self.sel is not None:
+            result["SEL"] = from_union([to_float, lambda x: to_class(Sel, x), from_none], self.sel)
+        if self.select is not None:
+            result["select"] = from_union([to_float, lambda x: to_class(Select, x), from_none], self.select)
+        if self.top_level_self is not None:
+            result["Self"] = from_union([to_float, lambda x: to_class(Self, x), from_none], self.top_level_self)
+        if self.purple_self is not None:
+            result["self"] = from_union([to_float, lambda x: to_class(SelfClass, x), from_none], self.purple_self)
+        if self.serialize is not None:
+            result["serialize"] = from_union([to_float, lambda x: to_class(Serialize, x), from_none], self.serialize)
+        if self.set is not None:
+            result["set"] = from_union([to_float, lambda x: to_class(Set, x), from_none], self.set)
+        if self.short is not None:
+            result["short"] = from_union([to_float, lambda x: to_class(Short, x), from_none], self.short)
+        if self.signed is not None:
+            result["signed"] = from_union([to_float, lambda x: to_class(Signed, x), from_none], self.signed)
+        if self.sizeof is not None:
+            result["sizeof"] = from_union([to_float, lambda x: to_class(Sizeof, x), from_none], self.sizeof)
+        if self.stackalloc is not None:
+            result["stackalloc"] = from_union([to_float, lambda x: to_class(Stackalloc, x), from_none], self.stackalloc)
+        if self.static is not None:
+            result["static"] = from_union([to_float, lambda x: to_class(Static, x), from_none], self.static)
+        if self.static_assert is not None:
+            result["static_assert"] = from_union([to_float, lambda x: to_class(StaticAssert, x), from_none], self.static_assert)
+        if self.static_cast is not None:
+            result["static_cast"] = from_union([to_float, lambda x: to_class(StaticCast, x), from_none], self.static_cast)
+        if self.strictfp is not None:
+            result["strictfp"] = from_union([to_float, lambda x: to_class(Strictfp, x), from_none], self.strictfp)
+        if self.string is not None:
+            result["string"] = from_union([to_float, lambda x: to_class(String, x), from_none], self.string)
+        if self.struct is not None:
+            result["struct"] = from_union([to_float, lambda x: to_class(Struct, x), from_none], self.struct)
+        if self.subscript is not None:
+            result["subscript"] = from_union([to_float, lambda x: to_class(Subscript, x), from_none], self.subscript)
+        if self.super is not None:
+            result["super"] = from_union([to_float, lambda x: to_class(Super, x), from_none], self.super)
+        if self.switch is not None:
+            result["switch"] = from_union([to_float, lambda x: to_class(Switch, x), from_none], self.switch)
+        if self.symbol is not None:
+            result["symbol"] = from_union([to_float, lambda x: to_class(Symbol, x), from_none], self.symbol)
+        if self.synchronized is not None:
+            result["synchronized"] = from_union([to_float, lambda x: to_class(Synchronized, x), from_none], self.synchronized)
+        if self.system is not None:
+            result["system"] = from_union([to_float, lambda x: to_class(System, x), from_none], self.system)
+        if self.template is not None:
+            result["template"] = from_union([to_float, lambda x: to_class(Template, x), from_none], self.template)
+        if self.then is not None:
+            result["then"] = from_union([to_float, lambda x: to_class(Then, x), from_none], self.then)
+        if self.this is not None:
+            result["this"] = from_union([to_float, lambda x: to_class(This, x), from_none], self.this)
+        if self.thread_local is not None:
+            result["thread_local"] = from_union([to_float, lambda x: to_class(ThreadLocal, x), from_none], self.thread_local)
+        if self.throw is not None:
+            result["throw"] = from_union([to_float, lambda x: to_class(Throw, x), from_none], self.throw)
+        if self.throws is not None:
+            result["throws"] = from_union([to_float, lambda x: to_class(Throws, x), from_none], self.throws)
+        if self.to_json is not None:
+            result["to_json"] = from_union([to_float, lambda x: to_class(ToJSON, x), from_none], self.to_json)
+        if self.top_level is not None:
+            result["top_level"] = from_union([to_float, lambda x: to_class(TopLevelClass, x), from_none], self.top_level)
+        if self.transient is not None:
+            result["transient"] = from_union([to_float, lambda x: to_class(Transient, x), from_none], self.transient)
+        if self.true is not None:
+            result["True"] = from_union([to_float, lambda x: to_class(TrueClass, x), from_none], self.true)
+        if self.top_level_true is not None:
+            result["true"] = from_union([to_float, lambda x: to_class(UnionTrueTrue, x), from_none], self.top_level_true)
+        if self.top_level_try is not None:
+            result["try"] = from_union([to_float, lambda x: to_class(Try, x), from_none], self.top_level_try)
+        if self.type is not None:
+            result["Type"] = from_union([to_float, lambda x: to_class(TypeClass, x), from_none], self.type)
+        if self.top_level_type is not None:
+            result["type"] = from_union([to_float, lambda x: to_class(UnionTypeType, x), from_none], self.top_level_type)
+        if self.typealias is not None:
+            result["typealias"] = from_union([to_float, lambda x: to_class(Typealias, x), from_none], self.typealias)
+        if self.typedef is not None:
+            result["typedef"] = from_union([to_float, lambda x: to_class(Typedef, x), from_none], self.typedef)
+        if self.typeid is not None:
+            result["typeid"] = from_union([to_float, lambda x: to_class(Typeid, x), from_none], self.typeid)
+        if self.typename is not None:
+            result["typename"] = from_union([to_float, lambda x: to_class(Typename, x), from_none], self.typename)
+        if self.typeof is not None:
+            result["typeof"] = from_union([to_float, lambda x: to_class(Typeof, x), from_none], self.typeof)
+        if self.uint is not None:
+            result["uint"] = from_union([to_float, lambda x: to_class(Uint, x), from_none], self.uint)
+        if self.ulong is not None:
+            result["ulong"] = from_union([to_float, lambda x: to_class(Ulong, x), from_none], self.ulong)
+        if self.unchecked is not None:
+            result["unchecked"] = from_union([to_float, lambda x: to_class(Unchecked, x), from_none], self.unchecked)
+        if self.undefined is not None:
+            result["undefined"] = from_union([to_float, lambda x: to_class(Undefined, x), from_none], self.undefined)
+        if self.union is not None:
+            result["union"] = from_union([to_float, lambda x: to_class(UnionClass, x), from_none], self.union)
+        if self.unowned is not None:
+            result["unowned"] = from_union([to_float, lambda x: to_class(Unowned, x), from_none], self.unowned)
+        if self.unsafe is not None:
+            result["unsafe"] = from_union([to_float, lambda x: to_class(Unsafe, x), from_none], self.unsafe)
+        if self.unsigned is not None:
+            result["unsigned"] = from_union([to_float, lambda x: to_class(Unsigned, x), from_none], self.unsigned)
+        if self.ushort is not None:
+            result["ushort"] = from_union([to_float, lambda x: to_class(Ushort, x), from_none], self.ushort)
+        if self.using is not None:
+            result["using"] = from_union([to_float, lambda x: to_class(Using, x), from_none], self.using)
+        if self.var is not None:
+            result["var"] = from_union([to_float, lambda x: to_class(Var, x), from_none], self.var)
+        if self.virtual is not None:
+            result["virtual"] = from_union([to_float, lambda x: to_class(Virtual, x), from_none], self.virtual)
+        if self.void is not None:
+            result["void"] = from_union([to_float, lambda x: to_class(Void, x), from_none], self.void)
+        if self.volatile is not None:
+            result["volatile"] = from_union([to_float, lambda x: to_class(Volatile, x), from_none], self.volatile)
+        if self.wchar_t is not None:
+            result["wchar_t"] = from_union([to_float, lambda x: to_class(WcharT, x), from_none], self.wchar_t)
+        if self.weak is not None:
+            result["weak"] = from_union([to_float, lambda x: to_class(Weak, x), from_none], self.weak)
+        if self.where is not None:
+            result["where"] = from_union([to_float, lambda x: to_class(Where, x), from_none], self.where)
+        if self.top_level_while is not None:
+            result["while"] = from_union([to_float, lambda x: to_class(While, x), from_none], self.top_level_while)
+        if self.will_set is not None:
+            result["willSet"] = from_union([to_float, lambda x: to_class(WillSet, x), from_none], self.will_set)
+        if self.top_level_with is not None:
+            result["with"] = from_union([to_float, lambda x: to_class(With, x), from_none], self.top_level_with)
+        if self.xor is not None:
+            result["xor"] = from_union([to_float, lambda x: to_class(Xor, x), from_none], self.xor)
+        if self.xor_eq is not None:
+            result["xor_eq"] = from_union([to_float, lambda x: to_class(XorEq, x), from_none], self.xor_eq)
+        if self.yes is not None:
+            result["YES"] = from_union([to_float, lambda x: to_class(Yes, x), from_none], self.yes)
+        if self.top_level_yield is not None:
+            result["yield"] = from_union([to_float, lambda x: to_class(Yield, x), from_none], self.top_level_yield)
+        return result
+
+
+def top_level_from_dict(s: Any) -> TopLevel:
+    return TopLevel.from_dict(s)
+
+
+def top_level_to_dict(x: TopLevel) -> Any:
+    return to_class(TopLevel, x)