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/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!");
+        }
+    }
+}